dlls/msi/tests/db.c

   1 /*
   2  * Copyright (C) 2005 Mike McCormack for CodeWeavers
   3  *
   4  * A test program for MSI database files.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdio.h>
  24
  25 #include <windows.h>
  26 #include <objidl.h>
  27 #include <msi.h>
  28 #include <msidefs.h>
  29 #include <msiquery.h>
  30
  31 #include "wine/test.h"
  32
  33 static const char *msifile = "winetest-db.msi";
  34 static const char *msifile2 = "winetst2-db.msi";
  35 static const char *mstfile = "winetst-db.mst";
  36 static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','-','d','b','.','m','s','i',0};
  37 static const WCHAR msifile2W[] = {'w','i','n','e','t','s','t','2','-','d','b','.','m','s','i',0};
  38
  39 static void test_msidatabase(void)
  40 {
  41     MSIHANDLE hdb = 0, hdb2 = 0;
  42     UINT res;
  43
  44     DeleteFileW(msifileW);
  45
  46     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb );
  47     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  48
  49     res = MsiOpenDatabaseW( msifileW, (LPWSTR)0xff, &hdb );
  50     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  51
  52     res = MsiCloseHandle( hdb );
  53     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  54
  55     /* create an empty database */
  56     res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
  57     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  58
  59     res = MsiDatabaseCommit( hdb );
  60     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  61
  62     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
  63
  64     res = MsiCloseHandle( hdb );
  65     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  66     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  67     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  68
  69     ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
  70
  71     res = MsiDatabaseCommit( hdb2 );
  72     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  73
  74     res = MsiCloseHandle( hdb2 );
  75     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  76
  77     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  78     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  79
  80     res = MsiCloseHandle( hdb2 );
  81     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  82
  83     ok( GetFileAttributesA( msifile2 ) == INVALID_FILE_ATTRIBUTES, "uncommitted database should not exist\n");
  84
  85     res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
  86     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  87
  88     res = MsiDatabaseCommit( hdb2 );
  89     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  90
  91     res = MsiCloseHandle( hdb2 );
  92     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  93
  94     ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "committed database should exist\n");
  95
  96     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
  97     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  98
  99     res = MsiDatabaseCommit( hdb );
 100     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 101
 102     res = MsiCloseHandle( hdb );
 103     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 104
 105     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_DIRECT, &hdb );
 106     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 107
 108     res = MsiCloseHandle( hdb );
 109     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 110
 111     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_TRANSACT, &hdb );
 112     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 113
 114     res = MsiCloseHandle( hdb );
 115     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 116     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 117
 118     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 119     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 120     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 121
 122     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 123
 124     res = MsiCloseHandle( hdb );
 125     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 126
 127     ok( GetFileAttributesA( msifile ) == INVALID_FILE_ATTRIBUTES, "database should exist\n");
 128
 129     res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
 130     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 131
 132     res = MsiDatabaseCommit( hdb );
 133     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 134
 135     ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 136
 137     res = MsiCloseHandle( hdb );
 138     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 139
 140     res = DeleteFileA( msifile2 );
 141     ok( res == TRUE, "Failed to delete database\n" );
 142
 143     res = DeleteFileA( msifile );
 144     ok( res == TRUE, "Failed to delete database\n" );
 145 }
 146
 147 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 148 {
 149     MSIHANDLE hview = 0;
 150     UINT r, ret;
 151
 152     if (phrec)
 153         *phrec = 0;
 154
 155     /* open a select query */
 156     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 157     if (r != ERROR_SUCCESS)
 158         return r;
 159     r = MsiViewExecute(hview, 0);
 160     if (r != ERROR_SUCCESS)
 161         return r;
 162     ret = MsiViewFetch(hview, phrec);
 163     r = MsiViewClose(hview);
 164     if (r != ERROR_SUCCESS)
 165         return r;
 166     r = MsiCloseHandle(hview);
 167     if (r != ERROR_SUCCESS)
 168         return r;
 169     return ret;
 170 }
 171
 172 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 173 {
 174     MSIHANDLE hview = 0;
 175     UINT r;
 176
 177     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 178     if( r != ERROR_SUCCESS )
 179         return r;
 180
 181     r = MsiViewExecute(hview, hrec);
 182     if( r == ERROR_SUCCESS )
 183         r = MsiViewClose(hview);
 184     MsiCloseHandle(hview);
 185     return r;
 186 }
 187
 188 static UINT run_queryW( MSIHANDLE hdb, MSIHANDLE hrec, const WCHAR *query )
 189 {
 190     MSIHANDLE hview = 0;
 191     UINT r;
 192
 193     r = MsiDatabaseOpenViewW(hdb, query, &hview);
 194     if( r != ERROR_SUCCESS )
 195         return r;
 196
 197     r = MsiViewExecute(hview, hrec);
 198     if( r == ERROR_SUCCESS )
 199         r = MsiViewClose(hview);
 200     MsiCloseHandle(hview);
 201     return r;
 202 }
 203
 204 static UINT create_component_table( MSIHANDLE hdb )
 205 {
 206     return run_query( hdb, 0,
 207             "CREATE TABLE `Component` ( "
 208             "`Component` CHAR(72) NOT NULL, "
 209             "`ComponentId` CHAR(38), "
 210             "`Directory_` CHAR(72) NOT NULL, "
 211             "`Attributes` SHORT NOT NULL, "
 212             "`Condition` CHAR(255), "
 213             "`KeyPath` CHAR(72) "
 214             "PRIMARY KEY `Component`)" );
 215 }
 216
 217 static UINT create_custom_action_table( MSIHANDLE hdb )
 218 {
 219     return run_query( hdb, 0,
 220             "CREATE TABLE `CustomAction` ( "
 221             "`Action` CHAR(72) NOT NULL, "
 222             "`Type` SHORT NOT NULL, "
 223             "`Source` CHAR(72), "
 224             "`Target` CHAR(255) "
 225             "PRIMARY KEY `Action`)" );
 226 }
 227
 228 static UINT create_directory_table( MSIHANDLE hdb )
 229 {
 230     return run_query( hdb, 0,
 231             "CREATE TABLE `Directory` ( "
 232             "`Directory` CHAR(255) NOT NULL, "
 233             "`Directory_Parent` CHAR(255), "
 234             "`DefaultDir` CHAR(255) NOT NULL "
 235             "PRIMARY KEY `Directory`)" );
 236 }
 237
 238 static UINT create_feature_components_table( MSIHANDLE hdb )
 239 {
 240     return run_query( hdb, 0,
 241             "CREATE TABLE `FeatureComponents` ( "
 242             "`Feature_` CHAR(38) NOT NULL, "
 243             "`Component_` CHAR(72) NOT NULL "
 244             "PRIMARY KEY `Feature_`, `Component_` )" );
 245 }
 246
 247 static UINT create_std_dlls_table( MSIHANDLE hdb )
 248 {
 249     return run_query( hdb, 0,
 250             "CREATE TABLE `StdDlls` ( "
 251             "`File` CHAR(255) NOT NULL, "
 252             "`Binary_` CHAR(72) NOT NULL "
 253             "PRIMARY KEY `File` )" );
 254 }
 255
 256 static UINT create_binary_table( MSIHANDLE hdb )
 257 {
 258     return run_query( hdb, 0,
 259             "CREATE TABLE `Binary` ( "
 260             "`Name` CHAR(72) NOT NULL, "
 261             "`Data` CHAR(72) NOT NULL "
 262             "PRIMARY KEY `Name` )" );
 263 }
 264
 265 #define make_add_entry(type, qtext) \
 266     static UINT add##_##type##_##entry( MSIHANDLE hdb, const char *values ) \
 267     { \
 268         char insert[] = qtext; \
 269         char *query; \
 270         UINT sz, r; \
 271         sz = strlen(values) + sizeof insert; \
 272         query = HeapAlloc(GetProcessHeap(),0,sz); \
 273         sprintf(query,insert,values); \
 274         r = run_query( hdb, 0, query ); \
 275         HeapFree(GetProcessHeap(), 0, query); \
 276         return r; \
 277     }
 278
 279 make_add_entry(component,
 280                "INSERT INTO `Component`  "
 281                "(`Component`, `ComponentId`, `Directory_`, "
 282                "`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
 283
 284 make_add_entry(custom_action,
 285                "INSERT INTO `CustomAction`  "
 286                "(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
 287
 288 make_add_entry(feature_components,
 289                "INSERT INTO `FeatureComponents` "
 290                "(`Feature_`, `Component_`) VALUES( %s )")
 291
 292 make_add_entry(std_dlls,
 293                "INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
 294
 295 make_add_entry(binary,
 296                "INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
 297
 298 static void test_msiinsert(void)
 299 {
 300     MSIHANDLE hdb = 0, hview = 0, hview2 = 0, hrec = 0;
 301     UINT r;
 302     const char *query;
 303     char buf[80];
 304     DWORD sz;
 305
 306     DeleteFileA(msifile);
 307
 308     /* just MsiOpenDatabase should not create a file */
 309     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 310     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 311
 312     /* create a table */
 313     query = "CREATE TABLE `phone` ( "
 314             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 315             "PRIMARY KEY `id`)";
 316     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 317     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 318     r = MsiViewExecute(hview, 0);
 319     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 320     r = MsiViewClose(hview);
 321     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 322     r = MsiCloseHandle(hview);
 323     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 324
 325     query = "SELECT * FROM phone WHERE number = '8675309'";
 326     r = MsiDatabaseOpenViewA(hdb, query, &hview2);
 327     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 328     r = MsiViewExecute(hview2, 0);
 329     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 330     r = MsiViewFetch(hview2, &hrec);
 331     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 332
 333     /* insert a value into it */
 334     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 335         "VALUES('1', 'Abe', '8675309')";
 336     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 337     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 338     r = MsiViewExecute(hview, 0);
 339     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 340     r = MsiViewClose(hview);
 341     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 342     r = MsiCloseHandle(hview);
 343     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 344
 345     r = MsiViewFetch(hview2, &hrec);
 346     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 347     r = MsiViewExecute(hview2, 0);
 348     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 349     r = MsiViewFetch(hview2, &hrec);
 350     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %u\n", r);
 351
 352     r = MsiCloseHandle(hrec);
 353     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 354     r = MsiViewClose(hview2);
 355     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 356     r = MsiCloseHandle(hview2);
 357     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 358
 359     query = "SELECT * FROM `phone` WHERE `id` = 1";
 360     r = do_query(hdb, query, &hrec);
 361     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 362
 363     /* check the record contains what we put in it */
 364     r = MsiRecordGetFieldCount(hrec);
 365     ok(r == 3, "record count wrong\n");
 366
 367     r = MsiRecordIsNull(hrec, 0);
 368     ok(r == FALSE, "field 0 not null\n");
 369
 370     r = MsiRecordGetInteger(hrec, 1);
 371     ok(r == 1, "field 1 contents wrong\n");
 372     sz = sizeof buf;
 373     r = MsiRecordGetStringA(hrec, 2, buf, &sz);
 374     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 375     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 376     sz = sizeof buf;
 377     r = MsiRecordGetStringA(hrec, 3, buf, &sz);
 378     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 379     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 380
 381     r = MsiCloseHandle(hrec);
 382     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 383
 384     /* open a select query */
 385     hrec = 100;
 386     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 387     r = do_query(hdb, query, &hrec);
 388     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 389     ok(hrec == 0, "hrec should be null\n");
 390
 391     r = MsiCloseHandle(hrec);
 392     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 393
 394     query = "SELECT * FROM `phone` WHERE `id` < 0";
 395     r = do_query(hdb, query, &hrec);
 396     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 397
 398     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 399     r = do_query(hdb, query, &hrec);
 400     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 401
 402     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 403     r = do_query(hdb, query, &hrec);
 404     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 405
 406     query = "SELECT * FROM `phone` WHERE `id` > 10";
 407     r = do_query(hdb, query, &hrec);
 408     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 409
 410     /* now try a few bad INSERT xqueries */
 411     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 412         "VALUES(?, ?)";
 413     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 414     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 415
 416     /* construct a record to insert */
 417     hrec = MsiCreateRecord(4);
 418     r = MsiRecordSetInteger(hrec, 1, 2);
 419     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 420     r = MsiRecordSetStringA(hrec, 2, "Adam");
 421     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 422     r = MsiRecordSetStringA(hrec, 3, "96905305");
 423     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 424
 425     /* insert another value, using a record and wildcards */
 426     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 427         "VALUES(?, ?, ?)";
 428     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 429     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 430
 431     if (r == ERROR_SUCCESS)
 432     {
 433         r = MsiViewExecute(hview, hrec);
 434         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 435         r = MsiViewClose(hview);
 436         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 437         r = MsiCloseHandle(hview);
 438         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 439     }
 440     r = MsiCloseHandle(hrec);
 441     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 442
 443     r = MsiViewFetch(0, NULL);
 444     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 445
 446     r = MsiDatabaseCommit(hdb);
 447     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 448
 449     r = MsiCloseHandle(hdb);
 450     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 451
 452     r = DeleteFileA(msifile);
 453     ok(r == TRUE, "file didn't exist after commit\n");
 454 }
 455
 456 static void test_msidecomposedesc(void)
 457 {
 458     UINT (WINAPI *pMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 459     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 460     const char *desc;
 461     UINT r;
 462     DWORD len;
 463     HMODULE hmod;
 464
 465     hmod = GetModuleHandleA("msi.dll");
 466     pMsiDecomposeDescriptorA = (void*)GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 467     if (!pMsiDecomposeDescriptorA)
 468         return;
 469
 470     /* test a valid feature descriptor */
 471     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 472     len = 0;
 473     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 474     ok(r == ERROR_SUCCESS, "returned an error\n");
 475     ok(len == strlen(desc), "length was wrong\n");
 476     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 477     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 478     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 479
 480     /* test an invalid feature descriptor with too many characters */
 481     desc = "']gAVn-}f(ZXfeAR6.ji"
 482            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 483            "3w2x^IGfe?CxI5heAvk.";
 484     len = 0;
 485     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 486     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 487
 488     /*
 489      * Test a valid feature descriptor with the
 490      * maximum number of characters and some trailing characters.
 491      */
 492     desc = "']gAVn-}f(ZXfeAR6.ji"
 493            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 494            "3w2x^IGfe?CxI5heAvk."
 495            "extra";
 496     len = 0;
 497     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 498     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 499     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 500
 501     len = 0;
 502     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 503     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 504     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 505
 506     len = 0;
 507     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 508     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 509     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 510
 511     len = 0;
 512     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 513     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 514     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 515
 516     len = 0;
 517     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 518     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 519     ok(len == 0, "length wrong\n");
 520
 521     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
 522     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 523 }
 524
 525 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 526 {
 527     MSIHANDLE htab = 0;
 528     UINT res;
 529
 530     res = MsiDatabaseOpenViewA( hdb, szQuery, &htab );
 531     if(res == ERROR_SUCCESS )
 532     {
 533         UINT r;
 534
 535         r = MsiViewExecute( htab, hrec );
 536         if(r != ERROR_SUCCESS )
 537             res = r;
 538
 539         r = MsiViewClose( htab );
 540         if(r != ERROR_SUCCESS )
 541             res = r;
 542
 543         r = MsiCloseHandle( htab );
 544         if(r != ERROR_SUCCESS )
 545             res = r;
 546     }
 547     return res;
 548 }
 549
 550 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 551 {
 552     return try_query_param( hdb, szQuery, 0 );
 553 }
 554
 555 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 556 {
 557     MSIHANDLE hrec = 0;
 558     UINT r;
 559
 560     hrec = MsiCreateRecord( 1 );
 561     MsiRecordSetStringA( hrec, 1, "Hello");
 562
 563     r = try_query_param( hdb, szQuery, hrec );
 564
 565     MsiCloseHandle( hrec );
 566     return r;
 567 }
 568
 569 static void test_msibadqueries(void)
 570 {
 571     MSIHANDLE hdb = 0;
 572     UINT r;
 573
 574     DeleteFileA(msifile);
 575
 576     /* just MsiOpenDatabase should not create a file */
 577     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 578     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 579
 580     r = MsiDatabaseCommit( hdb );
 581     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 582
 583     r = MsiCloseHandle( hdb );
 584     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 585
 586     /* open it readonly */
 587     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb );
 588     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 589
 590     /* add a table to it */
 591     r = try_query( hdb, "select * from _Tables");
 592     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 593
 594     r = MsiCloseHandle( hdb );
 595     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 596
 597     /* open it read/write */
 598     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
 599     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 600
 601     /* a bunch of test queries that fail with the native MSI */
 602
 603     r = try_query( hdb, "CREATE TABLE");
 604     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 605
 606     r = try_query( hdb, "CREATE TABLE `a`");
 607     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 608
 609     r = try_query( hdb, "CREATE TABLE `a` ()");
 610     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 611
 612     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 613     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 614
 615     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 616     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 617
 618     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 619     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 620
 621     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 622     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 623
 624     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 625     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 626
 627     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 628     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 629
 630     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 631     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 632
 633     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 634     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 635
 636     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 637     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 638
 639     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 640     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 641
 642     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 643     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 644
 645     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 646     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 647
 648     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 649     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 650
 651     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 652     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 653
 654     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 655     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 656
 657     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 658     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 659
 660     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 661           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 662     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 663
 664     r = MsiDatabaseCommit( hdb );
 665     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 666
 667     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 668                           "PRIMARY KEY `foo`)");
 669     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 670
 671     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 672     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 673
 674     r = MsiDatabaseCommit( hdb );
 675     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 676
 677     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 678                           "PRIMARY KEY `ba`)");
 679     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 680
 681     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 682     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 683
 684     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 685                           "PRIMARY KEY `t`)");
 686     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 687
 688     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 689     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 690
 691     r = try_query( hdb, "select * from c");
 692     ok(r == ERROR_SUCCESS , "query failed\n");
 693
 694     r = try_query( hdb, "select * from c where b = 'x");
 695     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 696
 697     r = try_query( hdb, "select * from c where b = 'x'");
 698     ok(r == ERROR_SUCCESS, "query failed\n");
 699
 700     r = try_query( hdb, "select * from 'c'");
 701     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 702
 703     r = try_query( hdb, "select * from ''");
 704     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 705
 706     r = try_query( hdb, "select * from c where b = x");
 707     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 708
 709     r = try_query( hdb, "select * from c where b = \"x\"");
 710     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 711
 712     r = try_query( hdb, "select * from c where b = 'x'");
 713     ok(r == ERROR_SUCCESS, "query failed\n");
 714
 715     r = try_query( hdb, "select * from c where b = '\"x'");
 716     ok(r == ERROR_SUCCESS, "query failed\n");
 717
 718     if (0)  /* FIXME: this query causes trouble with other tests */
 719     {
 720         r = try_query( hdb, "select * from c where b = '\\\'x'");
 721         ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 722     }
 723
 724     r = try_query( hdb, "select * from 'c'");
 725     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 726
 727     r = try_query( hdb, "select `c`.`b` from `c` order by `c`.`order`");
 728     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 729
 730     r = try_query( hdb, "select `c`.b` from `c`");
 731     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 732
 733     r = try_query( hdb, "select `c`.`b from `c`");
 734     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 735
 736     r = try_query( hdb, "select `c`.b from `c`");
 737     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 738
 739     r = try_query( hdb, "select `c.`b` from `c`");
 740     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 741
 742     r = try_query( hdb, "select c`.`b` from `c`");
 743     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 744
 745     r = try_query( hdb, "select c.`b` from `c`");
 746     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 747
 748     r = try_query( hdb, "select `c`.`b` from c`");
 749     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 750
 751     r = try_query( hdb, "select `c`.`b` from `c");
 752     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 753
 754     r = try_query( hdb, "select `c`.`b` from c");
 755     ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 756
 757     r = try_query( hdb, "CREATE TABLE `\5a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 758     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 759
 760     r = try_query( hdb, "SELECT * FROM \5a" );
 761     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 762
 763     r = try_query( hdb, "CREATE TABLE `a\5` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 764     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 765
 766     r = try_query( hdb, "SELECT * FROM a\5" );
 767     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 768
 769     r = try_query( hdb, "CREATE TABLE `-a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 770     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 771
 772     r = try_query( hdb, "SELECT * FROM -a" );
 773     todo_wine ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 774
 775     r = try_query( hdb, "CREATE TABLE `a-` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
 776     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 777
 778     r = try_query( hdb, "SELECT * FROM a-" );
 779     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 780
 781     r = MsiCloseHandle( hdb );
 782     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 783
 784     r = DeleteFileA( msifile );
 785     ok(r == TRUE, "file didn't exist after commit\n");
 786 }
 787
 788 static void test_viewmodify(void)
 789 {
 790     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 791     UINT r;
 792     MSIDBERROR err;
 793     const char *query;
 794     char buffer[0x100];
 795     DWORD sz;
 796
 797     DeleteFileA(msifile);
 798
 799     /* just MsiOpenDatabase should not create a file */
 800     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
 801     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 802
 803     query = "CREATE TABLE `phone` ( "
 804             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 805             "PRIMARY KEY `id`)";
 806     r = run_query( hdb, 0, query );
 807     ok(r == ERROR_SUCCESS, "query failed\n");
 808
 809     query = "CREATE TABLE `_Validation` ( "
 810             "`Table` CHAR(32) NOT NULL, `Column` CHAR(32) NOT NULL, "
 811             "`Nullable` CHAR(4) NOT NULL, `MinValue` INT, `MaxValue` INT, "
 812             "`KeyTable` CHAR(255), `KeyColumn` SHORT, `Category` CHAR(32), "
 813             "`Set` CHAR(255), `Description` CHAR(255) PRIMARY KEY `Table`, `Column`)";
 814     r = run_query( hdb, 0, query );
 815     ok(r == ERROR_SUCCESS, "query failed\n");
 816
 817     query = "INSERT INTO `_Validation` ( `Table`, `Column`, `Nullable` ) "
 818             "VALUES('phone', 'id', 'N')";
 819     r = run_query( hdb, 0, query );
 820     ok(r == ERROR_SUCCESS, "query failed\n");
 821
 822     /* check what the error function reports without doing anything */
 823     sz = 0;
 824     /* passing NULL as the 3rd param make function to crash on older platforms */
 825     err = MsiViewGetErrorA( 0, NULL, &sz );
 826     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 827
 828     /* open a view */
 829     query = "SELECT * FROM `phone`";
 830     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 831     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 832
 833     /* see what happens with a good hview and bad args */
 834     err = MsiViewGetErrorA( hview, NULL, NULL );
 835     ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
 836        "MsiViewGetError returns %u (expected -3)\n", err);
 837     err = MsiViewGetErrorA( hview, buffer, NULL );
 838     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 839
 840     /* see what happens with a zero length buffer */
 841     sz = 0;
 842     buffer[0] = 'x';
 843     err = MsiViewGetErrorA( hview, buffer, &sz );
 844     ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 845     ok(buffer[0] == 'x', "buffer cleared\n");
 846     ok(sz == 0, "size not zero\n");
 847
 848     /* ok this one is strange */
 849     sz = 0;
 850     err = MsiViewGetErrorA( hview, NULL, &sz );
 851     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 852     ok(sz == 0, "size not zero\n");
 853
 854     /* see if it really has an error */
 855     sz = sizeof buffer;
 856     buffer[0] = 'x';
 857     err = MsiViewGetErrorA( hview, buffer, &sz );
 858     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 859     ok(buffer[0] == 0, "buffer not cleared\n");
 860     ok(sz == 0, "size not zero\n");
 861
 862     r = MsiViewExecute(hview, 0);
 863     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 864
 865     /* try some invalid records */
 866     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 867     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 868     r = MsiViewModify(hview, -1, 0 );
 869     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 870
 871     /* try an small record */
 872     hrec = MsiCreateRecord(1);
 873     r = MsiViewModify(hview, -1, hrec );
 874     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 875
 876     sz = sizeof buffer;
 877     buffer[0] = 'x';
 878     err = MsiViewGetErrorA( hview, buffer, &sz );
 879     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 880     ok(buffer[0] == 0, "buffer not cleared\n");
 881     ok(sz == 0, "size not zero\n");
 882
 883     r = MsiCloseHandle(hrec);
 884     ok(r == ERROR_SUCCESS, "failed to close record\n");
 885
 886     /* insert a valid record */
 887     hrec = MsiCreateRecord(3);
 888
 889     r = MsiRecordSetInteger(hrec, 1, 1);
 890     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 891     r = MsiRecordSetStringA(hrec, 2, "bob");
 892     ok(r == ERROR_SUCCESS, "failed to set string\n");
 893     r = MsiRecordSetStringA(hrec, 3, "7654321");
 894     ok(r == ERROR_SUCCESS, "failed to set string\n");
 895
 896     r = MsiViewExecute(hview, 0);
 897     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 898     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 899     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 900
 901     /* validate it */
 902     r = MsiViewExecute(hview, 0);
 903     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 904
 905     r = MsiViewModify(hview, MSIMODIFY_VALIDATE_NEW, hrec );
 906     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed %u\n", r);
 907
 908     sz = sizeof buffer;
 909     buffer[0] = 'x';
 910     err = MsiViewGetErrorA( hview, buffer, &sz );
 911     ok(err == MSIDBERROR_DUPLICATEKEY, "MsiViewGetError returned %u\n", err);
 912     ok(!strcmp(buffer, "id"), "expected \"id\" c, got \"%s\"\n", buffer);
 913     ok(sz == 2, "size not 2\n");
 914
 915     /* insert the same thing again */
 916     r = MsiViewExecute(hview, 0);
 917     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 918
 919     /* should fail ... */
 920     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 921     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 922
 923     /* try to merge the same record */
 924     r = MsiViewExecute(hview, 0);
 925     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 926     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 927     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 928
 929     r = MsiCloseHandle(hrec);
 930     ok(r == ERROR_SUCCESS, "failed to close record\n");
 931
 932     /* try merging a new record */
 933     hrec = MsiCreateRecord(3);
 934
 935     r = MsiRecordSetInteger(hrec, 1, 10);
 936     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 937     r = MsiRecordSetStringA(hrec, 2, "pepe");
 938     ok(r == ERROR_SUCCESS, "failed to set string\n");
 939     r = MsiRecordSetStringA(hrec, 3, "7654321");
 940     ok(r == ERROR_SUCCESS, "failed to set string\n");
 941
 942     r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
 943     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 944     r = MsiViewExecute(hview, 0);
 945     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 946
 947     r = MsiCloseHandle(hrec);
 948     ok(r == ERROR_SUCCESS, "failed to close record\n");
 949
 950     r = MsiViewClose(hview);
 951     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 952     r = MsiCloseHandle(hview);
 953     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 954
 955     query = "SELECT * FROM `phone`";
 956     r = MsiDatabaseOpenViewA(hdb, query, &hview);
 957     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 958
 959     r = MsiViewExecute(hview, 0);
 960     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 961
 962     r = MsiViewFetch(hview, &hrec);
 963     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 964
 965     r = MsiRecordGetInteger(hrec, 1);
 966     ok(r == 1, "Expected 1, got %d\n", r);
 967
 968     sz = sizeof(buffer);
 969     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
 970     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 971     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
 972
 973     sz = sizeof(buffer);
 974     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
 975     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 976     ok(!lstrcmpA(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
 977
 978     /* update the view, non-primary key */
 979     r = MsiRecordSetStringA(hrec, 3, "3141592");
 980     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 981
 982     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 983     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 984
 985     /* do it again */
 986     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 987     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 988
 989     /* update the view, primary key */
 990     r = MsiRecordSetInteger(hrec, 1, 5);
 991     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 992
 993     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 994     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 995
 996     r = MsiCloseHandle(hrec);
 997     ok(r == ERROR_SUCCESS, "failed to close record\n");
 998
 999     r = MsiViewClose(hview);
1000     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1001     r = MsiCloseHandle(hview);
1002     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1003
1004     query = "SELECT * FROM `phone`";
1005     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1006     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1007
1008     r = MsiViewExecute(hview, 0);
1009     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1010
1011     r = MsiViewFetch(hview, &hrec);
1012     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1013
1014     r = MsiRecordGetInteger(hrec, 1);
1015     ok(r == 1, "Expected 1, got %d\n", r);
1016
1017     sz = sizeof(buffer);
1018     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
1019     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1020     ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
1021
1022     sz = sizeof(buffer);
1023     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
1024     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
1025     ok(!lstrcmpA(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
1026
1027     r = MsiCloseHandle(hrec);
1028     ok(r == ERROR_SUCCESS, "failed to close record\n");
1029
1030     /* use a record that doesn't come from a view fetch */
1031     hrec = MsiCreateRecord(3);
1032     ok(hrec != 0, "MsiCreateRecord failed\n");
1033
1034     r = MsiRecordSetInteger(hrec, 1, 3);
1035     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1036     r = MsiRecordSetStringA(hrec, 2, "jane");
1037     ok(r == ERROR_SUCCESS, "failed to set string\n");
1038     r = MsiRecordSetStringA(hrec, 3, "112358");
1039     ok(r == ERROR_SUCCESS, "failed to set string\n");
1040
1041     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1042     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1043
1044     r = MsiCloseHandle(hrec);
1045     ok(r == ERROR_SUCCESS, "failed to close record\n");
1046
1047     /* use a record that doesn't come from a view fetch, primary key matches */
1048     hrec = MsiCreateRecord(3);
1049     ok(hrec != 0, "MsiCreateRecord failed\n");
1050
1051     r = MsiRecordSetInteger(hrec, 1, 1);
1052     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1053     r = MsiRecordSetStringA(hrec, 2, "jane");
1054     ok(r == ERROR_SUCCESS, "failed to set string\n");
1055     r = MsiRecordSetStringA(hrec, 3, "112358");
1056     ok(r == ERROR_SUCCESS, "failed to set string\n");
1057
1058     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1059     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1060
1061     r = MsiCloseHandle(hrec);
1062     ok(r == ERROR_SUCCESS, "failed to close record\n");
1063
1064     hrec = MsiCreateRecord(3);
1065
1066     r = MsiRecordSetInteger(hrec, 1, 2);
1067     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1068     r = MsiRecordSetStringA(hrec, 2, "nick");
1069     ok(r == ERROR_SUCCESS, "failed to set string\n");
1070     r = MsiRecordSetStringA(hrec, 3, "141421");
1071     ok(r == ERROR_SUCCESS, "failed to set string\n");
1072
1073     r = MsiViewExecute(hview, 0);
1074     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1075     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
1076     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
1077
1078     r = MsiCloseHandle(hrec);
1079     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1080     r = MsiViewClose(hview);
1081     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1082     r = MsiCloseHandle(hview);
1083     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1084
1085     query = "SELECT * FROM `phone` WHERE `id` = 1";
1086     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1087     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1088     r = MsiViewExecute(hview, 0);
1089     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1090     r = MsiViewFetch(hview, &hrec);
1091     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1092
1093     /* change the id to match the second row */
1094     r = MsiRecordSetInteger(hrec, 1, 2);
1095     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1096     r = MsiRecordSetStringA(hrec, 2, "jerry");
1097     ok(r == ERROR_SUCCESS, "failed to set string\n");
1098
1099     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1100     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1101
1102     r = MsiCloseHandle(hrec);
1103     ok(r == ERROR_SUCCESS, "failed to close record\n");
1104     r = MsiViewClose(hview);
1105     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1106     r = MsiCloseHandle(hview);
1107     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1108
1109     /* broader search */
1110     query = "SELECT * FROM `phone` ORDER BY `id`";
1111     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1112     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1113     r = MsiViewExecute(hview, 0);
1114     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1115     r = MsiViewFetch(hview, &hrec);
1116     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1117
1118     /* change the id to match the second row */
1119     r = MsiRecordSetInteger(hrec, 1, 2);
1120     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1121     r = MsiRecordSetStringA(hrec, 2, "jerry");
1122     ok(r == ERROR_SUCCESS, "failed to set string\n");
1123
1124     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
1125     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
1126
1127     r = MsiCloseHandle(hrec);
1128     ok(r == ERROR_SUCCESS, "failed to close record\n");
1129     r = MsiViewClose(hview);
1130     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1131     r = MsiCloseHandle(hview);
1132     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1133
1134     r = MsiCloseHandle( hdb );
1135     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
1136 }
1137
1138 static MSIHANDLE create_db(void)
1139 {
1140     MSIHANDLE hdb = 0;
1141     UINT res;
1142
1143     DeleteFileW(msifileW);
1144
1145     /* create an empty database */
1146     res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1147     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
1148     if( res != ERROR_SUCCESS )
1149         return hdb;
1150
1151     res = MsiDatabaseCommit( hdb );
1152     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
1153
1154     return hdb;
1155 }
1156
1157 static void test_getcolinfo(void)
1158 {
1159     MSIHANDLE hdb, hview = 0, rec = 0;
1160     UINT r;
1161     DWORD sz;
1162     char buffer[0x20];
1163
1164     /* create an empty db */
1165     hdb = create_db();
1166     ok( hdb, "failed to create db\n");
1167
1168     /* tables should be present */
1169     r = MsiDatabaseOpenViewA(hdb, "select * from _Tables", &hview);
1170     ok( r == ERROR_SUCCESS, "failed to open query\n");
1171
1172     r = MsiViewExecute(hview, 0);
1173     ok( r == ERROR_SUCCESS, "failed to execute query\n");
1174
1175     /* check that NAMES works */
1176     rec = 0;
1177     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
1178     ok( r == ERROR_SUCCESS, "failed to get names\n");
1179     sz = sizeof buffer;
1180     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1181     ok( r == ERROR_SUCCESS, "failed to get string\n");
1182     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
1183     r = MsiCloseHandle( rec );
1184     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1185
1186     /* check that TYPES works */
1187     rec = 0;
1188     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
1189     ok( r == ERROR_SUCCESS, "failed to get names\n");
1190     sz = sizeof buffer;
1191     r = MsiRecordGetStringA(rec, 1, buffer, &sz );
1192     ok( r == ERROR_SUCCESS, "failed to get string\n");
1193     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
1194     r = MsiCloseHandle( rec );
1195     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1196
1197     /* check that invalid values fail */
1198     rec = 0;
1199     r = MsiViewGetColumnInfo( hview, 100, &rec );
1200     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1201     ok( rec == 0, "returned a record\n");
1202
1203     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
1204     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1205
1206     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
1207     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
1208
1209     r = MsiViewClose(hview);
1210     ok( r == ERROR_SUCCESS, "failed to close view\n");
1211     r = MsiCloseHandle(hview);
1212     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
1213     r = MsiCloseHandle(hdb);
1214     ok( r == ERROR_SUCCESS, "failed to close database\n");
1215 }
1216
1217 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
1218 {
1219     MSIHANDLE hview = 0, rec = 0;
1220     UINT r;
1221
1222     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1223     if( r != ERROR_SUCCESS )
1224         return r;
1225
1226     r = MsiViewExecute(hview, 0);
1227     if( r == ERROR_SUCCESS )
1228     {
1229         MsiViewGetColumnInfo( hview, type, &rec );
1230     }
1231     MsiViewClose(hview);
1232     MsiCloseHandle(hview);
1233     return rec;
1234 }
1235
1236 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
1237 {
1238     MSIHANDLE hview = 0, rec = 0;
1239     UINT r, type = 0;
1240     char query[0x100];
1241
1242     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
1243
1244     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1245     if( r != ERROR_SUCCESS )
1246         return r;
1247
1248     r = MsiViewExecute(hview, 0);
1249     if( r == ERROR_SUCCESS )
1250     {
1251         while (1)
1252         {
1253             r = MsiViewFetch( hview, &rec );
1254             if( r != ERROR_SUCCESS)
1255                 break;
1256             r = MsiRecordGetInteger( rec, 2 );
1257             if (r == field)
1258                 type = MsiRecordGetInteger( rec, 4 );
1259             MsiCloseHandle( rec );
1260         }
1261     }
1262     MsiViewClose(hview);
1263     MsiCloseHandle(hview);
1264     return type;
1265 }
1266
1267 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
1268 {
1269     CHAR buffer[0x20];
1270     UINT r;
1271     DWORD sz;
1272
1273     sz = sizeof buffer;
1274     r = MsiRecordGetStringA( rec, field, buffer, &sz );
1275     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
1276 }
1277
1278 static void test_viewgetcolumninfo(void)
1279 {
1280     MSIHANDLE hdb = 0, rec;
1281     UINT r;
1282
1283     hdb = create_db();
1284     ok( hdb, "failed to create db\n");
1285
1286     r = run_query( hdb, 0,
1287             "CREATE TABLE `Properties` "
1288             "( `Property` CHAR(255), "
1289             "  `Value` CHAR(1), "
1290             "  `Intvalue` INT, "
1291             "  `Integervalue` INTEGER, "
1292             "  `Shortvalue` SHORT, "
1293             "  `Longvalue` LONG, "
1294             "  `Longcharvalue` LONGCHAR "
1295             "  PRIMARY KEY `Property`)" );
1296     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1297
1298     /* check the column types */
1299     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1300     ok( rec, "failed to get column info record\n" );
1301
1302     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1303     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1304     ok( check_record( rec, 3, "I2"), "wrong record type\n");
1305     ok( check_record( rec, 4, "I2"), "wrong record type\n");
1306     ok( check_record( rec, 5, "I2"), "wrong record type\n");
1307     ok( check_record( rec, 6, "I4"), "wrong record type\n");
1308     ok( check_record( rec, 7, "S0"), "wrong record type\n");
1309
1310     MsiCloseHandle( rec );
1311
1312     /* check the type in _Columns */
1313     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1314     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1315     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
1316     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
1317     ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
1318     ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
1319     ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
1320
1321     /* now try the names */
1322     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1323     ok( rec, "failed to get column info record\n" );
1324
1325     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1326     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1327     ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
1328     ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
1329     ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
1330     ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
1331     ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
1332
1333     MsiCloseHandle( rec );
1334
1335     r = run_query( hdb, 0,
1336             "CREATE TABLE `Binary` "
1337             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1338     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1339
1340     /* check the column types */
1341     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1342     ok( rec, "failed to get column info record\n" );
1343
1344     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1345     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1346
1347     MsiCloseHandle( rec );
1348
1349     /* check the type in _Columns */
1350     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1351     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1352
1353     /* now try the names */
1354     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1355     ok( rec, "failed to get column info record\n" );
1356
1357     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1358     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1359     MsiCloseHandle( rec );
1360
1361     r = run_query( hdb, 0,
1362             "CREATE TABLE `UIText` "
1363             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1364     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1365
1366     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1367     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1368
1369     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1370     ok( rec, "failed to get column info record\n" );
1371     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1372     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1373     MsiCloseHandle( rec );
1374
1375     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1376     ok( rec, "failed to get column info record\n" );
1377     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1378     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1379     MsiCloseHandle( rec );
1380
1381     MsiCloseHandle( hdb );
1382 }
1383
1384 static void test_msiexport(void)
1385 {
1386     MSIHANDLE hdb = 0, hview = 0;
1387     UINT r;
1388     const char *query;
1389     char path[MAX_PATH];
1390     const char file[] = "phone.txt";
1391     HANDLE handle;
1392     char buffer[0x100];
1393     DWORD length;
1394     const char expected[] =
1395         "id\tname\tnumber\r\n"
1396         "I2\tS32\tS32\r\n"
1397         "phone\tid\r\n"
1398         "1\tAbe\t8675309\r\n";
1399
1400     DeleteFileW(msifileW);
1401
1402     /* just MsiOpenDatabase should not create a file */
1403     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1404     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1405
1406     /* create a table */
1407     query = "CREATE TABLE `phone` ( "
1408             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1409             "PRIMARY KEY `id`)";
1410     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1411     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1412     r = MsiViewExecute(hview, 0);
1413     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1414     r = MsiViewClose(hview);
1415     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1416     r = MsiCloseHandle(hview);
1417     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1418
1419     /* insert a value into it */
1420     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1421         "VALUES('1', 'Abe', '8675309')";
1422     r = MsiDatabaseOpenViewA(hdb, query, &hview);
1423     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1424     r = MsiViewExecute(hview, 0);
1425     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1426     r = MsiViewClose(hview);
1427     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1428     r = MsiCloseHandle(hview);
1429     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1430
1431     GetCurrentDirectoryA(MAX_PATH, path);
1432
1433     r = MsiDatabaseExportA(hdb, "phone", path, file);
1434     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1435
1436     MsiCloseHandle(hdb);
1437
1438     lstrcatA(path, "\\");
1439     lstrcatA(path, file);
1440
1441     /* check the data that was written */
1442     length = 0;
1443     memset(buffer, 0, sizeof buffer);
1444     handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1445     if (handle != INVALID_HANDLE_VALUE)
1446     {
1447         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1448         CloseHandle(handle);
1449         DeleteFileA(path);
1450     }
1451     else
1452         ok(0, "failed to open file %s\n", path);
1453
1454     ok( length == strlen(expected), "length of data wrong\n");
1455     ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
1456     DeleteFileA(msifile);
1457 }
1458
1459 static void test_longstrings(void)
1460 {
1461     const char insert_query[] =
1462         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1463     char *str;
1464     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1465     DWORD len;
1466     UINT r;
1467     const DWORD STRING_LENGTH = 0x10005;
1468
1469     DeleteFileW(msifileW);
1470     /* just MsiOpenDatabase should not create a file */
1471     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
1472     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1473
1474     /* create a table */
1475     r = try_query( hdb,
1476         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1477     ok(r == ERROR_SUCCESS, "query failed\n");
1478
1479     /* try a insert a very long string */
1480     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1481     len = strchr(insert_query, 'Z') - insert_query;
1482     strcpy(str, insert_query);
1483     memset(str+len, 'Z', STRING_LENGTH);
1484     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1485     r = try_query( hdb, str );
1486     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1487
1488     HeapFree(GetProcessHeap(), 0, str);
1489
1490     r = MsiDatabaseCommit(hdb);
1491     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1492     MsiCloseHandle(hdb);
1493
1494     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
1495     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1496
1497     r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
1498     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1499
1500     r = MsiViewExecute(hview, 0);
1501     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1502
1503     r = MsiViewFetch(hview, &hrec);
1504     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1505
1506     MsiViewClose(hview);
1507     MsiCloseHandle(hview);
1508
1509     r = MsiRecordGetStringA(hrec, 2, NULL, &len);
1510     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1511     ok(len == STRING_LENGTH, "string length wrong\n");
1512
1513     MsiCloseHandle(hrec);
1514     MsiCloseHandle(hdb);
1515     DeleteFileA(msifile);
1516 }
1517
1518 static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
1519 {
1520     HANDLE file;
1521     DWORD written;
1522
1523     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1524     if (file == INVALID_HANDLE_VALUE)
1525         return;
1526
1527     WriteFile(file, data, strlen(data), &written, NULL);
1528     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1529
1530     if (size)
1531     {
1532         SetFilePointer(file, size, NULL, FILE_BEGIN);
1533         SetEndOfFile(file);
1534     }
1535
1536     CloseHandle(file);
1537 }
1538
1539 #define create_file(name) create_file_data(name, name, 0)
1540
1541 static void test_streamtable(void)
1542 {
1543     MSIHANDLE hdb = 0, rec, view, hsi;
1544     char file[MAX_PATH];
1545     char buf[MAX_PATH];
1546     DWORD size;
1547     UINT r;
1548
1549     hdb = create_db();
1550     ok( hdb, "failed to create db\n");
1551
1552     r = run_query( hdb, 0,
1553             "CREATE TABLE `Properties` "
1554             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1555     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1556
1557     r = run_query( hdb, 0,
1558             "INSERT INTO `Properties` "
1559             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1560     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1561
1562     r = MsiDatabaseCommit( hdb );
1563     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1564
1565     MsiCloseHandle( hdb );
1566
1567     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
1568     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1569
1570     /* check the column types */
1571     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1572     ok( rec, "failed to get column info record\n" );
1573
1574     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1575     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1576
1577     MsiCloseHandle( rec );
1578
1579     /* now try the names */
1580     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1581     ok( rec, "failed to get column info record\n" );
1582
1583     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1584     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1585
1586     MsiCloseHandle( rec );
1587
1588     r = MsiDatabaseOpenViewA( hdb,
1589             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1590     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1591
1592     r = MsiViewExecute( view, 0 );
1593     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1594
1595     r = MsiViewFetch( view, &rec );
1596     ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
1597
1598     MsiCloseHandle( rec );
1599     MsiViewClose( view );
1600     MsiCloseHandle( view );
1601
1602     /* create a summary information stream */
1603     r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
1604     ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
1605
1606     r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
1607     ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
1608
1609     r = MsiSummaryInfoPersist( hsi );
1610     ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
1611
1612     MsiCloseHandle( hsi );
1613
1614     r = MsiDatabaseOpenViewA( hdb,
1615             "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
1616     ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
1617
1618     r = MsiViewExecute( view, 0 );
1619     ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
1620
1621     r = MsiViewFetch( view, &rec );
1622     ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
1623
1624     MsiCloseHandle( rec );
1625     MsiViewClose( view );
1626     MsiCloseHandle( view );
1627
1628     /* insert a file into the _Streams table */
1629     create_file( "test.txt" );
1630
1631     rec = MsiCreateRecord( 2 );
1632     MsiRecordSetStringA( rec, 1, "data" );
1633
1634     r = MsiRecordSetStreamA( rec, 2, "test.txt" );
1635     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1636
1637     DeleteFileA("test.txt");
1638
1639     r = MsiDatabaseOpenViewA( hdb,
1640             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1641     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1642
1643     r = MsiViewExecute( view, rec );
1644     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1645
1646     MsiCloseHandle( rec );
1647     MsiViewClose( view );
1648     MsiCloseHandle( view );
1649
1650     /* insert another one */
1651     create_file( "test1.txt" );
1652
1653     rec = MsiCreateRecord( 2 );
1654     MsiRecordSetStringA( rec, 1, "data1" );
1655
1656     r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
1657     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1658
1659     DeleteFileA("test1.txt");
1660
1661     r = MsiDatabaseOpenViewA( hdb,
1662             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1663     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1664
1665     r = MsiViewExecute( view, rec );
1666     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1667
1668     MsiCloseHandle( rec );
1669     MsiViewClose( view );
1670     MsiCloseHandle( view );
1671
1672     r = MsiDatabaseOpenViewA( hdb,
1673             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
1674     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1675
1676     r = MsiViewExecute( view, 0 );
1677     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1678
1679     r = MsiViewFetch( view, &rec );
1680     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1681
1682     size = MAX_PATH;
1683     r = MsiRecordGetStringA( rec, 1, file, &size );
1684     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1685     ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
1686
1687     size = MAX_PATH;
1688     memset(buf, 0, MAX_PATH);
1689     r = MsiRecordReadStream( rec, 2, buf, &size );
1690     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1691     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1692
1693     MsiCloseHandle( rec );
1694     MsiViewClose( view );
1695     MsiCloseHandle( view );
1696
1697     r = MsiDatabaseOpenViewA( hdb,
1698             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1699     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1700
1701     r = MsiViewExecute( view, 0 );
1702     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1703
1704     r = MsiViewFetch( view, &rec );
1705     ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1706
1707     size = MAX_PATH;
1708     r = MsiRecordGetStringA( rec, 1, file, &size );
1709     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1710     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1711
1712     size = MAX_PATH;
1713     memset(buf, 0, MAX_PATH);
1714     r = MsiRecordReadStream( rec, 2, buf, &size );
1715     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1716     ok( !lstrcmpA(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
1717
1718     MsiCloseHandle( rec );
1719     MsiViewClose( view );
1720     MsiCloseHandle( view );
1721
1722     /* perform an update */
1723     create_file( "test2.txt" );
1724     rec = MsiCreateRecord( 1 );
1725
1726     r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
1727     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1728
1729     DeleteFileA("test2.txt");
1730
1731     r = MsiDatabaseOpenViewA( hdb,
1732             "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
1733     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1734
1735     r = MsiViewExecute( view, rec );
1736     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1737
1738     MsiCloseHandle( rec );
1739     MsiViewClose( view );
1740     MsiCloseHandle( view );
1741
1742     r = MsiDatabaseOpenViewA( hdb,
1743             "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
1744     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1745
1746     r = MsiViewExecute( view, 0 );
1747     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1748
1749     r = MsiViewFetch( view, &rec );
1750     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1751
1752     size = MAX_PATH;
1753     r = MsiRecordGetStringA( rec, 1, file, &size );
1754     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1755     ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
1756
1757     size = MAX_PATH;
1758     memset(buf, 0, MAX_PATH);
1759     r = MsiRecordReadStream( rec, 2, buf, &size );
1760     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1761     todo_wine ok( !lstrcmpA(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
1762
1763     MsiCloseHandle( rec );
1764     MsiViewClose( view );
1765     MsiCloseHandle( view );
1766     MsiCloseHandle( hdb );
1767     DeleteFileA(msifile);
1768 }
1769
1770 static void test_binary(void)
1771 {
1772     MSIHANDLE hdb = 0, rec;
1773     char file[MAX_PATH];
1774     char buf[MAX_PATH];
1775     DWORD size;
1776     LPCSTR query;
1777     UINT r;
1778
1779     /* insert a file into the Binary table */
1780     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
1781     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1782
1783     query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
1784     r = run_query( hdb, 0, query );
1785     ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
1786
1787     create_file( "test.txt" );
1788     rec = MsiCreateRecord( 1 );
1789     r = MsiRecordSetStreamA( rec, 1, "test.txt" );
1790     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1791     DeleteFileA( "test.txt" );
1792
1793     query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
1794     r = run_query( hdb, rec, query );
1795     ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
1796
1797     r = MsiCloseHandle( rec );
1798     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1799
1800     r = MsiDatabaseCommit( hdb );
1801     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1802
1803     r = MsiCloseHandle( hdb );
1804     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1805
1806     /* read file from the Stream table */
1807     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
1808     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1809
1810     query = "SELECT * FROM `_Streams`";
1811     r = do_query( hdb, query, &rec );
1812     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1813
1814     size = MAX_PATH;
1815     r = MsiRecordGetStringA( rec, 1, file, &size );
1816     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1817     ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
1818
1819     size = MAX_PATH;
1820     memset( buf, 0, MAX_PATH );
1821     r = MsiRecordReadStream( rec, 2, buf, &size );
1822     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1823     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1824
1825     r = MsiCloseHandle( rec );
1826     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1827
1828     /* read file from the Binary table */
1829     query = "SELECT * FROM `Binary`";
1830     r = do_query( hdb, query, &rec );
1831     ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
1832
1833     size = MAX_PATH;
1834     r = MsiRecordGetStringA( rec, 1, file, &size );
1835     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
1836     ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
1837
1838     size = MAX_PATH;
1839     memset( buf, 0, MAX_PATH );
1840     r = MsiRecordReadStream( rec, 3, buf, &size );
1841     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
1842     ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
1843
1844     r = MsiCloseHandle( rec );
1845     ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
1846
1847     r = MsiCloseHandle( hdb );
1848     ok( r == ERROR_SUCCESS , "Failed to close database\n" );
1849
1850     DeleteFileA( msifile );
1851 }
1852
1853 static void test_where_not_in_selected(void)
1854 {
1855     MSIHANDLE hdb = 0, rec, view;
1856     LPCSTR query;
1857     UINT r;
1858
1859     hdb = create_db();
1860     ok( hdb, "failed to create db\n");
1861
1862     r = run_query(hdb, 0,
1863             "CREATE TABLE `IESTable` ("
1864             "`Action` CHAR(64), "
1865             "`Condition` CHAR(64), "
1866             "`Sequence` LONG PRIMARY KEY `Sequence`)");
1867     ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
1868
1869     r = run_query(hdb, 0,
1870             "CREATE TABLE `CATable` ("
1871             "`Action` CHAR(64), "
1872             "`Type` LONG PRIMARY KEY `Type`)");
1873     ok( r == S_OK, "Cannot create CATable table: %d\n", r);
1874
1875     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1876             "( `Action`, `Condition`, `Sequence`) "
1877             "VALUES ( 'clean', 'cond4', 4)");
1878     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1879
1880     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1881             "( `Action`, `Condition`, `Sequence`) "
1882             "VALUES ( 'depends', 'cond1', 1)");
1883     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1884
1885     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1886             "( `Action`, `Condition`, `Sequence`) "
1887             "VALUES ( 'build', 'cond2', 2)");
1888     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1889
1890     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1891             "( `Action`, `Condition`, `Sequence`) "
1892             "VALUES ( 'build2', 'cond6', 6)");
1893     ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1894
1895     r = run_query(hdb, 0, "INSERT INTO `IESTable` "
1896             "( `Action`, `Condition`, `Sequence`) "
1897             "VALUES ( 'build', 'cond3', 3)");
1898     ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
1899
1900     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1901             "( `Action`, `Type` ) "
1902             "VALUES ( 'build', 32)");
1903     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1904
1905     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1906             "( `Action`, `Type` ) "
1907             "VALUES ( 'depends', 64)");
1908     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1909
1910     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1911             "( `Action`, `Type` ) "
1912             "VALUES ( 'clean', 63)");
1913     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1914
1915     r = run_query(hdb, 0, "INSERT INTO `CATable` "
1916             "( `Action`, `Type` ) "
1917             "VALUES ( 'build2', 34)");
1918     ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
1919     query = "Select IESTable.Condition from CATable, IESTable where "
1920             "CATable.Action = IESTable.Action and CATable.Type = 32";
1921     r = MsiDatabaseOpenViewA(hdb, query, &view);
1922     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1923
1924     r = MsiViewExecute(view, 0);
1925     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1926
1927     r = MsiViewFetch(view, &rec);
1928     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1929
1930     ok( check_record( rec, 1, "cond2"), "wrong condition\n");
1931
1932     MsiCloseHandle( rec );
1933     r = MsiViewFetch(view, &rec);
1934     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1935
1936     ok( check_record( rec, 1, "cond3"), "wrong condition\n");
1937
1938     MsiCloseHandle( rec );
1939     MsiViewClose(view);
1940     MsiCloseHandle(view);
1941
1942     MsiCloseHandle( hdb );
1943     DeleteFileA(msifile);
1944 }
1945
1946
1947 static void test_where(void)
1948 {
1949     MSIHANDLE hdb = 0, rec, view;
1950     LPCSTR query;
1951     UINT r;
1952     DWORD size;
1953     CHAR buf[MAX_PATH];
1954     UINT count;
1955
1956     hdb = create_db();
1957     ok( hdb, "failed to create db\n");
1958
1959     r = run_query( hdb, 0,
1960             "CREATE TABLE `Media` ("
1961             "`DiskId` SHORT NOT NULL, "
1962             "`LastSequence` LONG, "
1963             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1964             "`Cabinet` CHAR(255), "
1965             "`VolumeLabel` CHAR(32), "
1966             "`Source` CHAR(72) "
1967             "PRIMARY KEY `DiskId`)" );
1968     ok( r == S_OK, "cannot create Media table: %d\n", r );
1969
1970     r = run_query( hdb, 0, "INSERT INTO `Media` "
1971             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1972             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1973     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1974
1975     r = run_query( hdb, 0, "INSERT INTO `Media` "
1976             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1977             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1978     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1979
1980     r = run_query( hdb, 0, "INSERT INTO `Media` "
1981             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1982             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1983     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1984
1985     query = "SELECT * FROM `Media`";
1986     r = do_query(hdb, query, &rec);
1987     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1988     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1989     MsiCloseHandle( rec );
1990
1991     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1992     r = do_query(hdb, query, &rec);
1993     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1994     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1995
1996     r = MsiRecordGetInteger(rec, 1);
1997     ok( 2 == r, "field wrong\n");
1998     r = MsiRecordGetInteger(rec, 2);
1999     ok( 1 == r, "field wrong\n");
2000     MsiCloseHandle( rec );
2001
2002     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
2003     r = MsiDatabaseOpenViewA(hdb, query, &view);
2004     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2005
2006     r = MsiViewExecute(view, 0);
2007     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2008
2009     r = MsiViewFetch(view, &rec);
2010     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2011
2012     count = MsiRecordGetFieldCount( rec );
2013     ok( count == 1, "Expected 1 record fields, got %d\n", count );
2014
2015     size = MAX_PATH;
2016     r = MsiRecordGetStringA( rec, 1, buf, &size );
2017     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2018     ok( !lstrcmpA( buf, "2" ), "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
2019     MsiCloseHandle( rec );
2020
2021     r = MsiViewFetch(view, &rec);
2022     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
2023
2024     size = MAX_PATH;
2025     r = MsiRecordGetStringA( rec, 1, buf, &size );
2026     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2027     ok( !lstrcmpA( buf, "3" ), "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
2028     MsiCloseHandle( rec );
2029
2030     r = MsiViewFetch(view, &rec);
2031     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2032
2033     MsiViewClose(view);
2034     MsiCloseHandle(view);
2035
2036     MsiCloseHandle( rec );
2037
2038     rec = 0;
2039     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
2040     r = do_query(hdb, query, &rec);
2041     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2042     MsiCloseHandle( rec );
2043
2044     rec = 0;
2045     query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
2046     r = do_query(hdb, query, &rec);
2047     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2048     MsiCloseHandle( rec );
2049
2050     rec = 0;
2051     query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
2052     r = do_query(hdb, query, &rec);
2053     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
2054     MsiCloseHandle( rec );
2055
2056     rec = 0;
2057     query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
2058     r = do_query(hdb, query, &rec);
2059     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
2060     MsiCloseHandle( rec );
2061
2062     rec = 0;
2063     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
2064     r = do_query(hdb, query, &rec);
2065     ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
2066     MsiCloseHandle( rec );
2067
2068     rec = MsiCreateRecord(1);
2069     MsiRecordSetStringA(rec, 1, "");
2070
2071     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
2072     r = MsiDatabaseOpenViewA(hdb, query, &view);
2073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2074     r = MsiViewExecute(view, rec);
2075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2076
2077     MsiCloseHandle(rec);
2078
2079     r = MsiViewFetch(view, &rec);
2080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2081
2082     MsiCloseHandle(rec);
2083     MsiViewClose(view);
2084     MsiCloseHandle(view);
2085
2086     MsiCloseHandle( hdb );
2087     DeleteFileA(msifile);
2088 }
2089
2090 static CHAR CURR_DIR[MAX_PATH];
2091
2092 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
2093                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
2094                                 "TestTable\tFirstPrimaryColumn\n"
2095                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
2096
2097 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
2098                                   "s255\ts255\n"
2099                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
2100                                   "papaya\tleaf\n"
2101                                   "papaya\tflower\n";
2102
2103 static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
2104                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2105                                 "Table\tA\r\n"
2106                                 "a\tb\tc\td\te\tf\n"
2107                                 "g\th\ti\t\rj\tk\tl\r\n";
2108
2109 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
2110                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
2111                                 "Table2\tA\r\n"
2112                                 "a\tb\tc\td\te\tf\n"
2113                                 "g\th\ti\tj\tk\tl\r\n";
2114
2115 static const CHAR suminfo[] = "PropertyId\tValue\n"
2116                               "i2\tl255\n"
2117                               "_SummaryInformation\tPropertyId\n"
2118                               "1\t1252\n"
2119                               "2\tInstaller Database\n"
2120                               "3\tInstaller description\n"
2121                               "4\tWineHQ\n"
2122                               "5\tInstaller\n"
2123                               "6\tInstaller comments\n"
2124                               "7\tIntel;1033,2057\n"
2125                               "9\t{12345678-1234-1234-1234-123456789012}\n"
2126                               "12\t2009/04/12 15:46:11\n"
2127                               "13\t2009/04/12 15:46:11\n"
2128                               "14\t200\n"
2129                               "15\t2\n"
2130                               "18\tVim\n"
2131                               "19\t2\n";
2132
2133 static void write_file(const CHAR *filename, const char *data, int data_size)
2134 {
2135     DWORD size;
2136
2137     HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
2138                             CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2139     WriteFile(hf, data, data_size, &size, NULL);
2140     CloseHandle(hf);
2141 }
2142
2143 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
2144 {
2145     UINT r;
2146
2147     write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
2148     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
2149     DeleteFileA("temp_file");
2150
2151     return r;
2152 }
2153
2154 static void test_suminfo_import(void)
2155 {
2156     MSIHANDLE hdb, hsi, view = 0;
2157     LPCSTR query;
2158     UINT r, count, size, type;
2159     char str_value[50];
2160     INT int_value;
2161     FILETIME ft_value;
2162
2163     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2164
2165     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2166     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2167
2168     r = add_table_to_db(hdb, suminfo);
2169     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2170
2171     /* _SummaryInformation is not imported as a regular table... */
2172
2173     query = "SELECT * FROM `_SummaryInformation`";
2174     r = MsiDatabaseOpenViewA(hdb, query, &view);
2175     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
2176     MsiCloseHandle(view);
2177
2178     /* ...its data is added to the special summary information stream */
2179
2180     r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
2181     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2182
2183     r = MsiSummaryInfoGetPropertyCount(hsi, &count);
2184     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2185     ok(count == 14, "Expected 14, got %u\n", count);
2186
2187     r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
2188     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2189     ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
2190     ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
2191
2192     size = sizeof(str_value);
2193     r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &type, NULL, NULL, str_value, &size);
2194     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2195     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2196     ok(size == 18, "Expected 18, got %u\n", size);
2197     ok(!strcmp(str_value, "Installer Database"),
2198        "Expected \"Installer Database\", got %s\n", str_value);
2199
2200     size = sizeof(str_value);
2201     r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
2202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2203     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2204     ok(!strcmp(str_value, "Installer description"),
2205        "Expected \"Installer description\", got %s\n", str_value);
2206
2207     size = sizeof(str_value);
2208     r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &type, NULL, NULL, str_value, &size);
2209     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2210     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2211     ok(!strcmp(str_value, "WineHQ"),
2212        "Expected \"WineHQ\", got %s\n", str_value);
2213
2214     size = sizeof(str_value);
2215     r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &type, NULL, NULL, str_value, &size);
2216     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2217     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2218     ok(!strcmp(str_value, "Installer"),
2219        "Expected \"Installer\", got %s\n", str_value);
2220
2221     size = sizeof(str_value);
2222     r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &type, NULL, NULL, str_value, &size);
2223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2224     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2225     ok(!strcmp(str_value, "Installer comments"),
2226        "Expected \"Installer comments\", got %s\n", str_value);
2227
2228     size = sizeof(str_value);
2229     r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &type, NULL, NULL, str_value, &size);
2230     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2231     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2232     ok(!strcmp(str_value, "Intel;1033,2057"),
2233        "Expected \"Intel;1033,2057\", got %s\n", str_value);
2234
2235     size = sizeof(str_value);
2236     r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &type, NULL, NULL, str_value, &size);
2237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2238     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2239     ok(!strcmp(str_value, "{12345678-1234-1234-1234-123456789012}"),
2240        "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
2241
2242     r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
2243     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2244     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2245
2246     r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
2247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2248     ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
2249
2250     r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
2251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2252     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2253     ok(int_value == 200, "Expected 200, got %d\n", int_value);
2254
2255     r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
2256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2257     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2258     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2259
2260     r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
2261     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2262     ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
2263     ok(int_value == 2, "Expected 2, got %d\n", int_value);
2264
2265     size = sizeof(str_value);
2266     r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
2267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
2268     ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
2269     ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
2270
2271     MsiCloseHandle(hsi);
2272     MsiCloseHandle(hdb);
2273     DeleteFileA(msifile);
2274 }
2275
2276 static void test_msiimport(void)
2277 {
2278     MSIHANDLE hdb, view, rec;
2279     LPCSTR query;
2280     UINT r, count;
2281     signed int i;
2282
2283     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
2284
2285     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2287
2288     r = add_table_to_db(hdb, test_data);
2289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2290
2291     r = add_table_to_db(hdb, two_primary);
2292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2293
2294     r = add_table_to_db(hdb, endlines1);
2295     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2296
2297     r = add_table_to_db(hdb, endlines2);
2298     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2299
2300     query = "SELECT * FROM `TestTable`";
2301     r = MsiDatabaseOpenViewA(hdb, query, &view);
2302     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2303
2304     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2306     count = MsiRecordGetFieldCount(rec);
2307     ok(count == 9, "Expected 9, got %d\n", count);
2308     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
2309     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
2310     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
2311     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
2312     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
2313     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
2314     ok(check_record(rec, 7, "String"), "Expected String\n");
2315     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
2316     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
2317     MsiCloseHandle(rec);
2318
2319     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2321     count = MsiRecordGetFieldCount(rec);
2322     ok(count == 9, "Expected 9, got %d\n", count);
2323     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2324     ok(check_record(rec, 2, "i2"), "Expected i2\n");
2325     ok(check_record(rec, 3, "i2"), "Expected i2\n");
2326     ok(check_record(rec, 4, "I2"), "Expected I2\n");
2327     ok(check_record(rec, 5, "i4"), "Expected i4\n");
2328     ok(check_record(rec, 6, "I4"), "Expected I4\n");
2329     ok(check_record(rec, 7, "S255"), "Expected S255\n");
2330     ok(check_record(rec, 8, "S0"), "Expected S0\n");
2331     ok(check_record(rec, 9, "s0"), "Expected s0\n");
2332     MsiCloseHandle(rec);
2333
2334     query = "SELECT * FROM `TestTable`";
2335     r = do_query(hdb, query, &rec);
2336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2337     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
2338     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
2339     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
2340     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
2341
2342     i = MsiRecordGetInteger(rec, 2);
2343     ok(i == 5, "Expected 5, got %d\n", i);
2344
2345     i = MsiRecordGetInteger(rec, 3);
2346     ok(i == 2, "Expected 2, got %d\n", i);
2347
2348     i = MsiRecordGetInteger(rec, 4);
2349     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2350
2351     i = MsiRecordGetInteger(rec, 5);
2352     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
2353
2354     i = MsiRecordGetInteger(rec, 6);
2355     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
2356
2357     MsiCloseHandle(rec);
2358     MsiViewClose(view);
2359     MsiCloseHandle(view);
2360
2361     query = "SELECT * FROM `TwoPrimary`";
2362     r = MsiDatabaseOpenViewA(hdb, query, &view);
2363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2364
2365     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2367     count = MsiRecordGetFieldCount(rec);
2368     ok(count == 2, "Expected 2, got %d\n", count);
2369     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
2370     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
2371
2372     MsiCloseHandle(rec);
2373
2374     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2375     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2376     count = MsiRecordGetFieldCount(rec);
2377     ok(count == 2, "Expected 2, got %d\n", count);
2378     ok(check_record(rec, 1, "s255"), "Expected s255\n");
2379     ok(check_record(rec, 2, "s255"), "Expected s255\n");
2380     MsiCloseHandle(rec);
2381
2382     r = MsiViewExecute(view, 0);
2383     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2384
2385     r = MsiViewFetch(view, &rec);
2386     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2387
2388     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2389     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
2390
2391     MsiCloseHandle(rec);
2392
2393     r = MsiViewFetch(view, &rec);
2394     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2395
2396     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
2397     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
2398
2399     MsiCloseHandle(rec);
2400
2401     r = MsiViewFetch(view, &rec);
2402     ok(r == ERROR_NO_MORE_ITEMS,
2403        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2404
2405     r = MsiViewClose(view);
2406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2407
2408     MsiCloseHandle(view);
2409
2410     query = "SELECT * FROM `Table`";
2411     r = MsiDatabaseOpenViewA(hdb, query, &view);
2412     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2413
2414     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2415     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2416     count = MsiRecordGetFieldCount(rec);
2417     ok(count == 6, "Expected 6, got %d\n", count);
2418     ok(check_record(rec, 1, "A"), "Expected A\n");
2419     ok(check_record(rec, 2, "B"), "Expected B\n");
2420     ok(check_record(rec, 3, "C"), "Expected C\n");
2421     ok(check_record(rec, 4, "D"), "Expected D\n");
2422     ok(check_record(rec, 5, "E"), "Expected E\n");
2423     ok(check_record(rec, 6, "F"), "Expected F\n");
2424     MsiCloseHandle(rec);
2425
2426     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2428     count = MsiRecordGetFieldCount(rec);
2429     ok(count == 6, "Expected 6, got %d\n", count);
2430     ok(check_record(rec, 1, "s72"), "Expected s72\n");
2431     ok(check_record(rec, 2, "s72"), "Expected s72\n");
2432     ok(check_record(rec, 3, "s72"), "Expected s72\n");
2433     ok(check_record(rec, 4, "s72"), "Expected s72\n");
2434     ok(check_record(rec, 5, "s72"), "Expected s72\n");
2435     ok(check_record(rec, 6, "s72"), "Expected s72\n");
2436     MsiCloseHandle(rec);
2437
2438     MsiViewClose(view);
2439     MsiCloseHandle(view);
2440
2441     query = "SELECT * FROM `Table`";
2442     r = MsiDatabaseOpenViewA(hdb, query, &view);
2443     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2444
2445     r = MsiViewExecute(view, 0);
2446     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2447
2448     r = MsiViewFetch(view, &rec);
2449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2450     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
2451     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
2452     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
2453     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
2454     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
2455     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
2456
2457     MsiCloseHandle(rec);
2458
2459     r = MsiViewFetch(view, &rec);
2460     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2461     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
2462     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
2463     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
2464     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
2465     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
2466     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
2467
2468     MsiCloseHandle(rec);
2469
2470     r = MsiViewFetch(view, &rec);
2471     ok(r == ERROR_NO_MORE_ITEMS,
2472        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2473
2474     MsiViewClose(view);
2475     MsiCloseHandle(view);
2476     MsiCloseHandle(hdb);
2477     DeleteFileA(msifile);
2478 }
2479
2480 static const CHAR bin_import_dat[] = "Name\tData\r\n"
2481                                      "s72\tV0\r\n"
2482                                      "Binary\tName\r\n"
2483                                      "filename1\tfilename1.ibd\r\n";
2484
2485 static void test_binary_import(void)
2486 {
2487     MSIHANDLE hdb = 0, rec;
2488     char file[MAX_PATH];
2489     char buf[MAX_PATH];
2490     char path[MAX_PATH];
2491     DWORD size;
2492     LPCSTR query;
2493     UINT r;
2494
2495     /* create files to import */
2496     write_file("bin_import.idt", bin_import_dat,
2497           (sizeof(bin_import_dat) - 1) * sizeof(char));
2498     CreateDirectoryA("bin_import", NULL);
2499     create_file_data("bin_import/filename1.ibd", "just some words", 15);
2500
2501     /* import files into database */
2502     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
2503     ok( r == ERROR_SUCCESS , "Failed to open database\n");
2504
2505     GetCurrentDirectoryA(MAX_PATH, path);
2506     r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
2507     ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
2508
2509     /* read file from the Binary table */
2510     query = "SELECT * FROM `Binary`";
2511     r = do_query(hdb, query, &rec);
2512     ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
2513
2514     size = MAX_PATH;
2515     r = MsiRecordGetStringA(rec, 1, file, &size);
2516     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
2517     ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
2518
2519     size = MAX_PATH;
2520     memset(buf, 0, MAX_PATH);
2521     r = MsiRecordReadStream(rec, 2, buf, &size);
2522     ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
2523     ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
2524
2525     r = MsiCloseHandle(rec);
2526     ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
2527
2528     r = MsiCloseHandle(hdb);
2529     ok(r == ERROR_SUCCESS , "Failed to close database\n");
2530
2531     DeleteFileA("bin_import/filename1.ibd");
2532     RemoveDirectoryA("bin_import");
2533     DeleteFileA("bin_import.idt");
2534 }
2535
2536 static void test_markers(void)
2537 {
2538     MSIHANDLE hdb, rec;
2539     LPCSTR query;
2540     UINT r;
2541
2542     hdb = create_db();
2543     ok( hdb, "failed to create db\n");
2544
2545     rec = MsiCreateRecord(3);
2546     MsiRecordSetStringA(rec, 1, "Table");
2547     MsiRecordSetStringA(rec, 2, "Apples");
2548     MsiRecordSetStringA(rec, 3, "Oranges");
2549
2550     /* try a legit create */
2551     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2552     r = run_query(hdb, 0, query);
2553     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2554     MsiCloseHandle(rec);
2555
2556     /* try table name as marker */
2557     rec = MsiCreateRecord(1);
2558     MsiRecordSetStringA(rec, 1, "Fable");
2559     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2560     r = run_query(hdb, rec, query);
2561     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2562
2563     /* verify that we just created a table called '?', not 'Fable' */
2564     r = try_query(hdb, "SELECT * from `Fable`");
2565     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2566
2567     r = try_query(hdb, "SELECT * from `?`");
2568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2569
2570     /* try table name as marker without backticks */
2571     MsiRecordSetStringA(rec, 1, "Mable");
2572     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2573     r = run_query(hdb, rec, query);
2574     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2575
2576     /* try one column name as marker */
2577     MsiRecordSetStringA(rec, 1, "One");
2578     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
2579     r = run_query(hdb, rec, query);
2580     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2581     MsiCloseHandle(rec);
2582
2583     /* try column names as markers */
2584     rec = MsiCreateRecord(2);
2585     MsiRecordSetStringA(rec, 1, "One");
2586     MsiRecordSetStringA(rec, 2, "Two");
2587     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
2588     r = run_query(hdb, rec, query);
2589     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2590     MsiCloseHandle(rec);
2591
2592     /* try names with backticks */
2593     rec = MsiCreateRecord(3);
2594     MsiRecordSetStringA(rec, 1, "One");
2595     MsiRecordSetStringA(rec, 2, "Two");
2596     MsiRecordSetStringA(rec, 3, "One");
2597     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2598     r = run_query(hdb, rec, query);
2599     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2600
2601     /* try names with backticks, minus definitions */
2602     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
2603     r = run_query(hdb, rec, query);
2604     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2605
2606     /* try names without backticks */
2607     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
2608     r = run_query(hdb, rec, query);
2609     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2610     MsiCloseHandle(rec);
2611
2612     /* try one long marker */
2613     rec = MsiCreateRecord(1);
2614     MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
2615     query = "CREATE TABLE `Mable` ( ? )";
2616     r = run_query(hdb, rec, query);
2617     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2618     MsiCloseHandle(rec);
2619
2620     /* try all names as markers */
2621     rec = MsiCreateRecord(4);
2622     MsiRecordSetStringA(rec, 1, "Mable");
2623     MsiRecordSetStringA(rec, 2, "One");
2624     MsiRecordSetStringA(rec, 3, "Two");
2625     MsiRecordSetStringA(rec, 4, "One");
2626     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
2627     r = run_query(hdb, rec, query);
2628     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2629     MsiCloseHandle(rec);
2630
2631     /* try a legit insert */
2632     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
2633     r = run_query(hdb, 0, query);
2634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2635
2636     r = try_query(hdb, "SELECT * from `Table`");
2637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2638
2639     /* try values as markers */
2640     rec = MsiCreateRecord(2);
2641     MsiRecordSetInteger(rec, 1, 4);
2642     MsiRecordSetStringA(rec, 2, "hi");
2643     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2644     r = run_query(hdb, rec, query);
2645     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2646     MsiCloseHandle(rec);
2647
2648     /* try column names and values as markers */
2649     rec = MsiCreateRecord(4);
2650     MsiRecordSetStringA(rec, 1, "One");
2651     MsiRecordSetStringA(rec, 2, "Two");
2652     MsiRecordSetInteger(rec, 3, 5);
2653     MsiRecordSetStringA(rec, 4, "hi");
2654     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
2655     r = run_query(hdb, rec, query);
2656     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2657     MsiCloseHandle(rec);
2658
2659     /* try column names as markers */
2660     rec = MsiCreateRecord(2);
2661     MsiRecordSetStringA(rec, 1, "One");
2662     MsiRecordSetStringA(rec, 2, "Two");
2663     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
2664     r = run_query(hdb, rec, query);
2665     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2666     MsiCloseHandle(rec);
2667
2668     /* try table name as a marker */
2669     rec = MsiCreateRecord(1);
2670     MsiRecordSetStringA(rec, 1, "Table");
2671     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
2672     r = run_query(hdb, rec, query);
2673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2674     MsiCloseHandle(rec);
2675
2676     /* try table name and values as markers */
2677     rec = MsiCreateRecord(3);
2678     MsiRecordSetStringA(rec, 1, "Table");
2679     MsiRecordSetInteger(rec, 2, 10);
2680     MsiRecordSetStringA(rec, 3, "haha");
2681     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
2682     r = run_query(hdb, rec, query);
2683     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2684     MsiCloseHandle(rec);
2685
2686     /* try all markers */
2687     rec = MsiCreateRecord(5);
2688     MsiRecordSetStringA(rec, 1, "Table");
2689     MsiRecordSetStringA(rec, 1, "One");
2690     MsiRecordSetStringA(rec, 1, "Two");
2691     MsiRecordSetInteger(rec, 2, 10);
2692     MsiRecordSetStringA(rec, 3, "haha");
2693     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
2694     r = run_query(hdb, rec, query);
2695     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
2696     MsiCloseHandle(rec);
2697
2698     /* insert an integer as a string */
2699     rec = MsiCreateRecord(2);
2700     MsiRecordSetStringA(rec, 1, "11");
2701     MsiRecordSetStringA(rec, 2, "hi");
2702     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
2703     r = run_query(hdb, rec, query);
2704     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2705     MsiCloseHandle(rec);
2706
2707     /* leave off the '' for the string */
2708     rec = MsiCreateRecord(2);
2709     MsiRecordSetInteger(rec, 1, 12);
2710     MsiRecordSetStringA(rec, 2, "hi");
2711     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2712     r = run_query(hdb, rec, query);
2713     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2714     MsiCloseHandle(rec);
2715
2716     MsiCloseHandle(hdb);
2717     DeleteFileA(msifile);
2718 }
2719
2720 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
2721 static void test_handle_limit(void)
2722 {
2723     int i;
2724     MSIHANDLE hdb;
2725     MSIHANDLE hviews[MY_NVIEWS];
2726     UINT r;
2727
2728     /* create an empty db */
2729     hdb = create_db();
2730     ok( hdb, "failed to create db\n");
2731
2732     memset(hviews, 0, sizeof(hviews));
2733
2734     for (i=0; i<MY_NVIEWS; i++) {
2735         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2736         hviews[i] = 0xdeadbeeb;
2737         r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
2738         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2739             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2740             break;
2741     }
2742
2743     ok( i == MY_NVIEWS, "problem opening views\n");
2744
2745     for (i=0; i<MY_NVIEWS; i++) {
2746         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2747             MsiViewClose(hviews[i]);
2748             r = MsiCloseHandle(hviews[i]);
2749             if (r != ERROR_SUCCESS)
2750                 break;
2751         }
2752     }
2753
2754     ok( i == MY_NVIEWS, "problem closing views\n");
2755
2756     r = MsiCloseHandle(hdb);
2757     ok( r == ERROR_SUCCESS, "failed to close database\n");
2758 }
2759
2760 static void generate_transform(void)
2761 {
2762     MSIHANDLE hdb1, hdb2, hrec;
2763     LPCSTR query;
2764     UINT r;
2765
2766     /* start with two identical databases */
2767     CopyFileA(msifile2, msifile, FALSE);
2768
2769     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
2770     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2771
2772     r = MsiDatabaseCommit( hdb1 );
2773     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2774
2775     r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
2776     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2777
2778     /* the transform between two identical database should be empty */
2779     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
2780     todo_wine {
2781     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2782     }
2783
2784     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2785     r = run_query(hdb1, 0, query);
2786     ok(r == ERROR_SUCCESS, "failed to add table\n");
2787
2788     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2789     r = run_query(hdb1, 0, query);
2790     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2791
2792     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2793     r = run_query(hdb1, 0, query);
2794     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2795
2796     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2797     r = run_query(hdb1, 0, query);
2798     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2799
2800     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2801     r = run_query(hdb1, 0, query);
2802     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2803
2804     hrec = MsiCreateRecord(2);
2805     r = MsiRecordSetInteger(hrec, 1, 1);
2806     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2807
2808     write_file("testdata.bin", "naengmyon", 9);
2809     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
2810     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2811
2812     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2813     r = run_query(hdb1, hrec, query);
2814     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2815
2816     MsiCloseHandle(hrec);
2817
2818     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2819     r = run_query(hdb1, 0, query);
2820     ok(r == ERROR_SUCCESS, "failed to add column\n");
2821
2822     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2823     r = run_query(hdb1, 0, query);
2824     ok(r == ERROR_SUCCESS, "failed to add column\n");
2825
2826     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2827     r = run_query(hdb1, 0, query);
2828     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2829
2830     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2831             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2832     r = run_query(hdb1, 0, query);
2833     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2834
2835     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2836     r = run_query(hdb1, 0, query);
2837     ok(r == ERROR_SUCCESS, "failed to add property\n");
2838
2839     /* database needs to be committed */
2840     MsiDatabaseCommit(hdb1);
2841
2842     r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
2843     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2844
2845     MsiCloseHandle( hdb1 );
2846     MsiCloseHandle( hdb2 );
2847
2848     DeleteFileA("testdata.bin");
2849 }
2850
2851 /* data for generating a transform */
2852
2853 /* tables transform names - encoded as they would be in an msi database file */
2854 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2855 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2856 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2857 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2858 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2859 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2860 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2861 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2862 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2863
2864 /* data in each table */
2865 static const WCHAR data1[] = { /* AAR */
2866     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2867     0x0201, 0x0009, 0x8002,
2868 };
2869 static const WCHAR data2[] = { /* _Columns */
2870     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2871     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2872     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2873     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2874     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2875     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2876 };
2877 static const WCHAR data3[] = { /* _Tables */
2878     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2879     0x0101, 0x000a,
2880 };
2881 static const char data4[] = /* _StringData */
2882     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2883 static const WCHAR data5[] = { /* _StringPool */
2884 /*  len, refs */
2885     0,   0,    /* string 0 ''    */
2886     3,   2,    /* string 1 'MOO' */
2887     3,   1,    /* string 2 'COW' */
2888     3,   1,    /* string 3 'PIG' */
2889     1,   1,    /* string 4 'c'   */
2890     3,   3,    /* string 5 'AAR' */
2891     3,   1,    /* string 6 'CAR' */
2892     3,   1,    /* string 7 'BAR' */
2893     2,   1,    /* string 8 'vw'  */
2894     3,   1,    /* string 9 'bmw' */
2895     8,   4,    /* string 10 'Property' */
2896     5,   1,    /* string 11 'Value' */
2897     4,   1,    /* string 12 'prop' */
2898     3,   1,    /* string 13 'val' */
2899 };
2900 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2901 static const WCHAR data6[] = { /* MOO */
2902     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2903     0x0000, 0x8003,         /* delete row */
2904 };
2905
2906 static const WCHAR data7[] = { /* BINARY */
2907     0x0201, 0x8001, 0x0001,
2908 };
2909
2910 static const char data8[] =  /* stream data for the BINARY table */
2911     "naengmyon";
2912
2913 static const WCHAR data9[] = { /* Property */
2914     0x0201, 0x000c, 0x000d,
2915 };
2916
2917 static const struct {
2918     LPCWSTR name;
2919     const void *data;
2920     DWORD size;
2921 } table_transform_data[] =
2922 {
2923     { name1, data1, sizeof data1 },
2924     { name2, data2, sizeof data2 },
2925     { name3, data3, sizeof data3 },
2926     { name4, data4, sizeof data4 - 1 },
2927     { name5, data5, sizeof data5 },
2928     { name6, data6, sizeof data6 },
2929     { name7, data7, sizeof data7 },
2930     { name8, data8, sizeof data8 - 1 },
2931     { name9, data9, sizeof data9 },
2932 };
2933
2934 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2935
2936 static void generate_transform_manual(void)
2937 {
2938     IStorage *stg = NULL;
2939     IStream *stm;
2940     WCHAR name[0x20];
2941     HRESULT r;
2942     DWORD i, count;
2943     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2944
2945     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
2946
2947     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
2948
2949     r = StgCreateDocfile(name, mode, 0, &stg);
2950     ok(r == S_OK, "failed to create storage\n");
2951     if (!stg)
2952         return;
2953
2954     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
2955     ok(r == S_OK, "failed to set storage type\n");
2956
2957     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
2958     {
2959         r = IStorage_CreateStream( stg, table_transform_data[i].name,
2960                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
2961         if (FAILED(r))
2962         {
2963             ok(0, "failed to create stream %08x\n", r);
2964             continue;
2965         }
2966
2967         r = IStream_Write( stm, table_transform_data[i].data,
2968                           table_transform_data[i].size, &count );
2969         if (FAILED(r) || count != table_transform_data[i].size)
2970             ok(0, "failed to write stream\n");
2971         IStream_Release(stm);
2972     }
2973
2974     IStorage_Release(stg);
2975 }
2976
2977 static UINT set_summary_info(MSIHANDLE hdb)
2978 {
2979     UINT res;
2980     MSIHANDLE suminfo;
2981
2982     /* build summary info */
2983     res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
2984     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
2985
2986     res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
2987                         "Installation Database");
2988     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2989
2990     res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
2991                         "Installation Database");
2992     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2993
2994     res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
2995                         "Wine Hackers");
2996     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2997
2998     res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
2999                     ";1033,2057");
3000     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3001
3002     res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
3003                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
3004     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3005
3006     res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
3007     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3008
3009     res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
3010     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3011
3012     res = MsiSummaryInfoPersist(suminfo);
3013     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
3014
3015     res = MsiCloseHandle( suminfo);
3016     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
3017
3018     return res;
3019 }
3020
3021 static MSIHANDLE create_package_db(const WCHAR *filename)
3022 {
3023     MSIHANDLE hdb = 0;
3024     UINT res;
3025
3026     DeleteFileW(msifileW);
3027
3028     /* create an empty database */
3029     res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
3030     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
3031     if( res != ERROR_SUCCESS )
3032         return hdb;
3033
3034     res = MsiDatabaseCommit( hdb );
3035     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
3036
3037     res = set_summary_info(hdb);
3038     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
3039
3040     res = create_directory_table(hdb);
3041     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
3042
3043     return hdb;
3044 }
3045
3046 static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
3047 {
3048     UINT res;
3049     CHAR szPackage[12];
3050     MSIHANDLE hPackage;
3051
3052     sprintf(szPackage, "#%u", hdb);
3053     res = MsiOpenPackageA(szPackage, &hPackage);
3054     if (res != ERROR_SUCCESS)
3055         return res;
3056
3057     res = MsiCloseHandle(hdb);
3058     if (res != ERROR_SUCCESS)
3059     {
3060         MsiCloseHandle(hPackage);
3061         return res;
3062     }
3063
3064     *handle = hPackage;
3065     return ERROR_SUCCESS;
3066 }
3067
3068 static void test_try_transform(void)
3069 {
3070     MSIHANDLE hdb, hview, hrec, hpkg = 0;
3071     LPCSTR query;
3072     UINT r;
3073     DWORD sz;
3074     char buffer[MAX_PATH];
3075
3076     DeleteFileA(msifile);
3077     DeleteFileA(mstfile);
3078
3079     /* create the database */
3080     hdb = create_package_db(msifileW);
3081     ok(hdb, "Failed to create package db\n");
3082
3083     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
3084     r = run_query(hdb, 0, query);
3085     ok(r == ERROR_SUCCESS, "failed to add table\n");
3086
3087     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
3088     r = run_query(hdb, 0, query);
3089     ok(r == ERROR_SUCCESS, "failed to add row\n");
3090
3091     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
3092     r = run_query(hdb, 0, query);
3093     ok(r == ERROR_SUCCESS, "failed to add row\n");
3094
3095     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
3096     r = run_query(hdb, 0, query);
3097     ok(r == ERROR_SUCCESS, "failed to add row\n");
3098
3099     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
3100     r = run_query(hdb, 0, query);
3101     ok(r == ERROR_SUCCESS, "failed to add table\n");
3102
3103     hrec = MsiCreateRecord(2);
3104     r = MsiRecordSetInteger(hrec, 1, 2);
3105     ok(r == ERROR_SUCCESS, "failed to set integer\n");
3106
3107     write_file("testdata.bin", "lamyon", 6);
3108     r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
3109     ok(r == ERROR_SUCCESS, "failed to set stream\n");
3110
3111     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
3112     r = run_query(hdb, hrec, query);
3113     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
3114
3115     MsiCloseHandle(hrec);
3116
3117     r = MsiDatabaseCommit( hdb );
3118     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
3119
3120     MsiCloseHandle( hdb );
3121     DeleteFileA("testdata.bin");
3122
3123     /*
3124      * Both these generate an equivalent transform,
3125      *  but the first doesn't work in Wine yet
3126      *  because MsiDatabaseGenerateTransform is unimplemented.
3127      */
3128     if (0)
3129         generate_transform();
3130     else
3131         generate_transform_manual();
3132
3133     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
3134     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
3135
3136     r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
3137     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
3138
3139     MsiDatabaseCommit( hdb );
3140
3141     /* check new values */
3142     hrec = 0;
3143     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
3144     r = do_query(hdb, query, &hrec);
3145     ok(r == ERROR_SUCCESS, "select query failed\n");
3146     MsiCloseHandle(hrec);
3147
3148     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
3149     hrec = 0;
3150     r = do_query(hdb, query, &hrec);
3151     ok(r == ERROR_SUCCESS, "select query failed\n");
3152     MsiCloseHandle(hrec);
3153
3154     /* check updated values */
3155     hrec = 0;
3156     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
3157     r = do_query(hdb, query, &hrec);
3158     ok(r == ERROR_SUCCESS, "select query failed\n");
3159     MsiCloseHandle(hrec);
3160
3161     /* check unchanged value */
3162     hrec = 0;
3163     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
3164     r = do_query(hdb, query, &hrec);
3165     ok(r == ERROR_SUCCESS, "select query failed\n");
3166     MsiCloseHandle(hrec);
3167
3168     /* check deleted value */
3169     hrec = 0;
3170     query = "select * from `MOO` where `NOO` = 3";
3171     r = do_query(hdb, query, &hrec);
3172     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
3173     if (hrec) MsiCloseHandle(hrec);
3174
3175     /* check added stream */
3176     hrec = 0;
3177     query = "select `BLOB` from `BINARY` where `ID` = 1";
3178     r = do_query(hdb, query, &hrec);
3179     ok(r == ERROR_SUCCESS, "select query failed\n");
3180
3181     /* check the contents of the stream */
3182     sz = sizeof buffer;
3183     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
3184     ok(r == ERROR_SUCCESS, "read stream failed\n");
3185     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
3186     ok(sz == 9, "stream data was wrong size\n");
3187     if (hrec) MsiCloseHandle(hrec);
3188
3189     /* check the validity of the table with a deleted row */
3190     hrec = 0;
3191     query = "select * from `MOO`";
3192     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3193     ok(r == ERROR_SUCCESS, "open view failed\n");
3194
3195     r = MsiViewExecute(hview, 0);
3196     ok(r == ERROR_SUCCESS, "view execute failed\n");
3197
3198     r = MsiViewFetch(hview, &hrec);
3199     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3200
3201     r = MsiRecordGetInteger(hrec, 1);
3202     ok(r == 1, "Expected 1, got %d\n", r);
3203
3204     sz = sizeof buffer;
3205     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3206     ok(r == ERROR_SUCCESS, "record get string failed\n");
3207     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
3208
3209     r = MsiRecordGetInteger(hrec, 3);
3210     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3211
3212     r = MsiRecordGetInteger(hrec, 4);
3213     ok(r == 5, "Expected 5, got %d\n", r);
3214
3215     MsiCloseHandle(hrec);
3216
3217     r = MsiViewFetch(hview, &hrec);
3218     ok(r == ERROR_SUCCESS, "view fetch failed\n");
3219
3220     r = MsiRecordGetInteger(hrec, 1);
3221     ok(r == 2, "Expected 2, got %d\n", r);
3222
3223     sz = sizeof buffer;
3224     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
3225     ok(r == ERROR_SUCCESS, "record get string failed\n");
3226     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
3227
3228     r = MsiRecordGetInteger(hrec, 3);
3229     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3230
3231     r = MsiRecordGetInteger(hrec, 4);
3232     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
3233
3234     MsiCloseHandle(hrec);
3235
3236     r = MsiViewFetch(hview, &hrec);
3237     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
3238
3239     MsiCloseHandle(hrec);
3240     MsiViewClose(hview);
3241     MsiCloseHandle(hview);
3242
3243     /* check that the property was added */
3244     r = package_from_db(hdb, &hpkg);
3245     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
3246     {
3247         skip("Not enough rights to perform tests\n");
3248         goto error;
3249     }
3250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
3251
3252     sz = MAX_PATH;
3253     r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
3254     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3255     ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
3256
3257     MsiCloseHandle(hpkg);
3258
3259 error:
3260     MsiCloseHandle(hdb);
3261     DeleteFileA(msifile);
3262     DeleteFileA(mstfile);
3263 }
3264
3265 struct join_res
3266 {
3267     const CHAR one[MAX_PATH];
3268     const CHAR two[MAX_PATH];
3269 };
3270
3271 struct join_res_4col
3272 {
3273     const CHAR one[MAX_PATH];
3274     const CHAR two[MAX_PATH];
3275     const CHAR three[MAX_PATH];
3276     const CHAR four[MAX_PATH];
3277 };
3278
3279 struct join_res_uint
3280 {
3281     UINT one;
3282     UINT two;
3283     UINT three;
3284     UINT four;
3285     UINT five;
3286     UINT six;
3287 };
3288
3289 static const struct join_res join_res_first[] =
3290 {
3291     { "alveolar", "procerus" },
3292     { "septum", "procerus" },
3293     { "septum", "nasalis" },
3294     { "ramus", "nasalis" },
3295     { "malar", "mentalis" },
3296 };
3297
3298 static const struct join_res join_res_second[] =
3299 {
3300     { "nasal", "septum" },
3301     { "mandible", "ramus" },
3302 };
3303
3304 static const struct join_res join_res_third[] =
3305 {
3306     { "msvcp.dll", "abcdefgh" },
3307     { "msvcr.dll", "ijklmnop" },
3308 };
3309
3310 static const struct join_res join_res_fourth[] =
3311 {
3312     { "msvcp.dll.01234", "single.dll.31415" },
3313 };
3314
3315 static const struct join_res join_res_fifth[] =
3316 {
3317     { "malar", "procerus" },
3318 };
3319
3320 static const struct join_res join_res_sixth[] =
3321 {
3322     { "malar", "procerus" },
3323     { "malar", "procerus" },
3324     { "malar", "nasalis" },
3325     { "malar", "nasalis" },
3326     { "malar", "nasalis" },
3327     { "malar", "mentalis" },
3328 };
3329
3330 static const struct join_res join_res_seventh[] =
3331 {
3332     { "malar", "nasalis" },
3333     { "malar", "nasalis" },
3334     { "malar", "nasalis" },
3335 };
3336
3337 static const struct join_res_4col join_res_eighth[] =
3338 {
3339     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
3340     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
3341     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
3342     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
3343     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
3344     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
3345 };
3346
3347 static const struct join_res_uint join_res_ninth[] =
3348 {
3349     { 1, 2, 3, 4, 7, 8 },
3350     { 1, 2, 5, 6, 7, 8 },
3351     { 1, 2, 3, 4, 9, 10 },
3352     { 1, 2, 5, 6, 9, 10 },
3353     { 1, 2, 3, 4, 11, 12 },
3354     { 1, 2, 5, 6, 11, 12 },
3355 };
3356
3357 static void test_join(void)
3358 {
3359     MSIHANDLE hdb, hview, hrec;
3360     LPCSTR query;
3361     CHAR buf[MAX_PATH];
3362     UINT r, count;
3363     DWORD size, i;
3364     BOOL data_correct;
3365
3366     hdb = create_db();
3367     ok( hdb, "failed to create db\n");
3368
3369     r = create_component_table( hdb );
3370     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
3371
3372     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
3373     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3374
3375     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
3376     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3377
3378     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
3379     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3380
3381     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
3382     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
3383
3384     r = create_feature_components_table( hdb );
3385     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
3386
3387     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
3388     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3389
3390     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
3391     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3392
3393     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
3394     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3395
3396     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
3397     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3398
3399     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
3400     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3401
3402     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
3403     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
3404
3405     r = create_std_dlls_table( hdb );
3406     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
3407
3408     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
3409     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3410
3411     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
3412     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
3413
3414     r = create_binary_table( hdb );
3415     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
3416
3417     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
3418     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3419
3420     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
3421     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3422
3423     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
3424     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
3425
3426     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
3427     r = run_query( hdb, 0, query);
3428     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3429
3430     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
3431     r = run_query( hdb, 0, query);
3432     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3433
3434     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
3435     r = run_query( hdb, 0, query);
3436     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3437
3438     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
3439     r = run_query( hdb, 0, query);
3440     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3441
3442     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
3443     r = run_query( hdb, 0, query);
3444     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3445
3446     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
3447     r = run_query( hdb, 0, query);
3448     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3449
3450     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
3451     r = run_query( hdb, 0, query);
3452     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3453
3454     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
3455     r = run_query( hdb, 0, query);
3456     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3457
3458     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
3459     r = run_query( hdb, 0, query);
3460     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3461
3462     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
3463     r = run_query( hdb, 0, query);
3464     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3465
3466     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
3467     r = run_query( hdb, 0, query);
3468     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
3469
3470     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
3471     r = run_query( hdb, 0, query);
3472     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3473
3474     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
3475     r = run_query( hdb, 0, query);
3476     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
3477
3478     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3479             "FROM `Component`, `FeatureComponents` "
3480             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3481             "ORDER BY `Feature_`";
3482     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3483     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3484
3485     r = MsiViewExecute(hview, 0);
3486     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3487
3488     i = 0;
3489     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3490     {
3491         count = MsiRecordGetFieldCount( hrec );
3492         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3493
3494         size = MAX_PATH;
3495         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3496         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3497         ok( !lstrcmpA( buf, join_res_first[i].one ),
3498             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
3499
3500         size = MAX_PATH;
3501         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3502         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3503         ok( !lstrcmpA( buf, join_res_first[i].two ),
3504             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
3505
3506         i++;
3507         MsiCloseHandle(hrec);
3508     }
3509
3510     ok( i == 5, "Expected 5 rows, got %d\n", i );
3511     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3512
3513     MsiViewClose(hview);
3514     MsiCloseHandle(hview);
3515
3516     /* try a join without a WHERE condition */
3517     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3518             "FROM `Component`, `FeatureComponents` ";
3519     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3520     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3521
3522     r = MsiViewExecute(hview, 0);
3523     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3524
3525     i = 0;
3526     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3527     {
3528         i++;
3529         MsiCloseHandle(hrec);
3530     }
3531     ok( i == 24, "Expected 24 rows, got %d\n", i );
3532
3533     MsiViewClose(hview);
3534     MsiCloseHandle(hview);
3535
3536     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
3537             "WHERE FeatureComponents.Component_=Component.Component "
3538             "AND (Feature_='nasalis') ORDER BY Feature_";
3539     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3540     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3541
3542     r = MsiViewExecute(hview, 0);
3543     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3544
3545     i = 0;
3546     data_correct = TRUE;
3547     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3548     {
3549         count = MsiRecordGetFieldCount( hrec );
3550         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3551
3552         size = MAX_PATH;
3553         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3554         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3555         if( lstrcmpA( buf, join_res_second[i].one ))
3556             data_correct = FALSE;
3557
3558         size = MAX_PATH;
3559         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3560         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3561         if( lstrcmpA( buf, join_res_second[i].two ))
3562             data_correct = FALSE;
3563
3564         i++;
3565         MsiCloseHandle(hrec);
3566     }
3567
3568     ok( data_correct, "data returned in the wrong order\n");
3569
3570     ok( i == 2, "Expected 2 rows, got %d\n", i );
3571     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3572
3573     MsiViewClose(hview);
3574     MsiCloseHandle(hview);
3575
3576     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3577             "FROM `StdDlls`, `Binary` "
3578             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
3579             "ORDER BY `File`";
3580     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3581     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3582
3583     r = MsiViewExecute(hview, 0);
3584     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3585
3586     i = 0;
3587     data_correct = TRUE;
3588     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3589     {
3590         count = MsiRecordGetFieldCount( hrec );
3591         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3592
3593         size = MAX_PATH;
3594         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3595         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3596         if( lstrcmpA( buf, join_res_third[i].one ) )
3597             data_correct = FALSE;
3598
3599         size = MAX_PATH;
3600         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3601         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3602         if( lstrcmpA( buf, join_res_third[i].two ) )
3603             data_correct = FALSE;
3604
3605         i++;
3606         MsiCloseHandle(hrec);
3607     }
3608     ok( data_correct, "data returned in the wrong order\n");
3609
3610     ok( i == 2, "Expected 2 rows, got %d\n", i );
3611
3612     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3613
3614     MsiViewClose(hview);
3615     MsiCloseHandle(hview);
3616
3617     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
3618             "FROM `StdDlls`, `Binary` "
3619             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
3620             "ORDER BY `Name`";
3621     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3622     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3623
3624     r = MsiViewExecute(hview, 0);
3625     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3626
3627     i = 0;
3628     data_correct = TRUE;
3629     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3630     {
3631         count = MsiRecordGetFieldCount( hrec );
3632         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3633
3634         size = MAX_PATH;
3635         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3636         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3637         if( lstrcmpA( buf, join_res_fourth[i].one ))
3638             data_correct = FALSE;
3639
3640         size = MAX_PATH;
3641         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3642         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3643         if( lstrcmpA( buf, join_res_fourth[i].two ))
3644             data_correct = FALSE;
3645
3646         i++;
3647         MsiCloseHandle(hrec);
3648     }
3649     ok( data_correct, "data returned in the wrong order\n");
3650
3651     ok( i == 1, "Expected 1 rows, got %d\n", i );
3652     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3653
3654     MsiViewClose(hview);
3655     MsiCloseHandle(hview);
3656
3657     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3658             "FROM `Component`, `FeatureComponents` "
3659             "WHERE `Component`.`Component` = 'zygomatic' "
3660             "AND `FeatureComponents`.`Component_` = 'maxilla' "
3661             "ORDER BY `Feature_`";
3662     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3663     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3664
3665     r = MsiViewExecute(hview, 0);
3666     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3667
3668     i = 0;
3669     data_correct = TRUE;
3670     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3671     {
3672         count = MsiRecordGetFieldCount( hrec );
3673         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3674
3675         size = MAX_PATH;
3676         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3677         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3678         if( lstrcmpA( buf, join_res_fifth[i].one ))
3679             data_correct = FALSE;
3680
3681         size = MAX_PATH;
3682         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3683         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3684         if( lstrcmpA( buf, join_res_fifth[i].two ))
3685             data_correct = FALSE;
3686
3687         i++;
3688         MsiCloseHandle(hrec);
3689     }
3690     ok( data_correct, "data returned in the wrong order\n");
3691
3692     ok( i == 1, "Expected 1 rows, got %d\n", i );
3693     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3694
3695     MsiViewClose(hview);
3696     MsiCloseHandle(hview);
3697
3698     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3699             "FROM `Component`, `FeatureComponents` "
3700             "WHERE `Component` = 'zygomatic' "
3701             "ORDER BY `Feature_`";
3702     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3703     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3704
3705     r = MsiViewExecute(hview, 0);
3706     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3707
3708     i = 0;
3709     data_correct = TRUE;
3710     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3711     {
3712         count = MsiRecordGetFieldCount( hrec );
3713         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3714
3715         size = MAX_PATH;
3716         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3717         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3718         if( lstrcmpA( buf, join_res_sixth[i].one ))
3719             data_correct = FALSE;
3720
3721         size = MAX_PATH;
3722         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3723         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3724         if( lstrcmpA( buf, join_res_sixth[i].two ))
3725             data_correct = FALSE;
3726
3727         i++;
3728         MsiCloseHandle(hrec);
3729     }
3730     ok( data_correct, "data returned in the wrong order\n");
3731
3732     ok( i == 6, "Expected 6 rows, got %d\n", i );
3733     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3734
3735     MsiViewClose(hview);
3736     MsiCloseHandle(hview);
3737
3738     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3739             "FROM `Component`, `FeatureComponents` "
3740             "WHERE `Component` = 'zygomatic' "
3741             "AND `Feature_` = 'nasalis' "
3742             "ORDER BY `Feature_`";
3743     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3744     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3745
3746     r = MsiViewExecute(hview, 0);
3747     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3748
3749     i = 0;
3750     data_correct = TRUE;
3751     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3752     {
3753         count = MsiRecordGetFieldCount( hrec );
3754         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3755
3756         size = MAX_PATH;
3757         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3758         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3759         if( lstrcmpA( buf, join_res_seventh[i].one ))
3760             data_correct = FALSE;
3761
3762         size = MAX_PATH;
3763         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3764         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3765         if( lstrcmpA( buf, join_res_seventh[i].two ))
3766             data_correct = FALSE;
3767
3768         i++;
3769         MsiCloseHandle(hrec);
3770     }
3771
3772     ok( data_correct, "data returned in the wrong order\n");
3773     ok( i == 3, "Expected 3 rows, got %d\n", i );
3774     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3775
3776     MsiViewClose(hview);
3777     MsiCloseHandle(hview);
3778
3779     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3780             "FROM `StdDlls`, `Binary` ";
3781     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3782     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3783
3784     r = MsiViewExecute(hview, 0);
3785     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3786
3787     i = 0;
3788     data_correct = TRUE;
3789     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3790     {
3791         count = MsiRecordGetFieldCount( hrec );
3792         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3793
3794         size = MAX_PATH;
3795         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3796         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3797         if( lstrcmpA( buf, join_res_eighth[i].one ))
3798             data_correct = FALSE;
3799
3800         size = MAX_PATH;
3801         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3802         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3803         if( lstrcmpA( buf, join_res_eighth[i].four ))
3804             data_correct = FALSE;
3805
3806         i++;
3807         MsiCloseHandle(hrec);
3808     }
3809
3810     ok( data_correct, "data returned in the wrong order\n");
3811     ok( i == 6, "Expected 6 rows, got %d\n", i );
3812     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3813
3814     MsiViewClose(hview);
3815     MsiCloseHandle(hview);
3816
3817     query = "SELECT * FROM `StdDlls`, `Binary` ";
3818     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3819     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3820
3821     r = MsiViewExecute(hview, 0);
3822     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3823
3824     i = 0;
3825     data_correct = TRUE;
3826     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3827     {
3828         count = MsiRecordGetFieldCount( hrec );
3829         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3830
3831         size = MAX_PATH;
3832         r = MsiRecordGetStringA( hrec, 1, buf, &size );
3833         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3834         if( lstrcmpA( buf, join_res_eighth[i].one ))
3835             data_correct = FALSE;
3836
3837         size = MAX_PATH;
3838         r = MsiRecordGetStringA( hrec, 2, buf, &size );
3839         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3840         if( lstrcmpA( buf, join_res_eighth[i].two ))
3841             data_correct = FALSE;
3842
3843         size = MAX_PATH;
3844         r = MsiRecordGetStringA( hrec, 3, buf, &size );
3845         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3846         if( lstrcmpA( buf, join_res_eighth[i].three ))
3847             data_correct = FALSE;
3848
3849         size = MAX_PATH;
3850         r = MsiRecordGetStringA( hrec, 4, buf, &size );
3851         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3852         if( lstrcmpA( buf, join_res_eighth[i].four ))
3853             data_correct = FALSE;
3854
3855         i++;
3856         MsiCloseHandle(hrec);
3857     }
3858     ok( data_correct, "data returned in the wrong order\n");
3859
3860     ok( i == 6, "Expected 6 rows, got %d\n", i );
3861     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3862
3863     MsiViewClose(hview);
3864     MsiCloseHandle(hview);
3865
3866     query = "SELECT * FROM `One`, `Two`, `Three` ";
3867     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3868     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3869
3870     r = MsiViewExecute(hview, 0);
3871     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3872
3873     i = 0;
3874     data_correct = TRUE;
3875     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3876     {
3877         count = MsiRecordGetFieldCount( hrec );
3878         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3879
3880         r = MsiRecordGetInteger( hrec, 1 );
3881         if( r != join_res_ninth[i].one )
3882             data_correct = FALSE;
3883
3884         r = MsiRecordGetInteger( hrec, 2 );
3885         if( r != join_res_ninth[i].two )
3886             data_correct = FALSE;
3887
3888         r = MsiRecordGetInteger( hrec, 3 );
3889         if( r != join_res_ninth[i].three )
3890             data_correct = FALSE;
3891
3892         r = MsiRecordGetInteger( hrec, 4 );
3893         if( r != join_res_ninth[i].four )
3894             data_correct = FALSE;
3895
3896         r = MsiRecordGetInteger( hrec, 5 );
3897         if( r != join_res_ninth[i].five )
3898             data_correct = FALSE;
3899
3900         r = MsiRecordGetInteger( hrec, 6);
3901         if( r != join_res_ninth[i].six )
3902             data_correct = FALSE;
3903
3904         i++;
3905         MsiCloseHandle(hrec);
3906     }
3907     ok( data_correct, "data returned in the wrong order\n");
3908
3909     ok( i == 6, "Expected 6 rows, got %d\n", i );
3910     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3911
3912     MsiViewClose(hview);
3913     MsiCloseHandle(hview);
3914
3915     query = "SELECT * FROM `Four`, `Five`";
3916     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3917     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3918
3919     r = MsiViewExecute(hview, 0);
3920     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3921
3922     r = MsiViewFetch(hview, &hrec);
3923     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3924
3925     MsiViewClose(hview);
3926     MsiCloseHandle(hview);
3927
3928     query = "SELECT * FROM `Nonexistent`, `One`";
3929     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3930     ok( r == ERROR_BAD_QUERY_SYNTAX,
3931         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3932
3933     /* try updating a row in a join table */
3934     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3935             "FROM `Component`, `FeatureComponents` "
3936             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
3937             "ORDER BY `Feature_`";
3938     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3939     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3940
3941     r = MsiViewExecute(hview, 0);
3942     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3943
3944     r = MsiViewFetch(hview, &hrec);
3945     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
3946
3947     r = MsiRecordSetStringA( hrec, 1, "epicranius" );
3948     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
3949
3950     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
3951     ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
3952
3953     /* try another valid operation for joins */
3954     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
3955     todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
3956
3957     /* try an invalid operation for joins */
3958     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
3959     ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
3960
3961     r = MsiRecordSetStringA( hrec, 2, "epicranius" );
3962     ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
3963
3964     /* primary key cannot be updated */
3965     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
3966     ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
3967
3968     MsiCloseHandle(hrec);
3969     MsiViewClose(hview);
3970     MsiCloseHandle(hview);
3971
3972     r = MsiDatabaseOpenViewA(hdb, query, &hview);
3973     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3974
3975     r = MsiViewExecute(hview, 0);
3976     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3977
3978     r = MsiViewFetch(hview, &hrec);
3979     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
3980
3981     size = MAX_PATH;
3982     r = MsiRecordGetStringA( hrec, 1, buf, &size );
3983     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3984     ok( !lstrcmpA( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
3985
3986     MsiCloseHandle(hrec);
3987     MsiViewClose(hview);
3988     MsiCloseHandle(hview);
3989
3990     MsiCloseHandle(hdb);
3991     DeleteFileA(msifile);
3992 }
3993
3994 static void test_temporary_table(void)
3995 {
3996     MSICONDITION cond;
3997     MSIHANDLE hdb = 0, view = 0, rec;
3998     const char *query;
3999     UINT r;
4000     char buf[0x10];
4001     DWORD sz;
4002
4003     cond = MsiDatabaseIsTablePersistentA(0, NULL);
4004     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4005
4006     hdb = create_db();
4007     ok( hdb, "failed to create db\n");
4008
4009     cond = MsiDatabaseIsTablePersistentA(hdb, NULL);
4010     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
4011
4012     cond = MsiDatabaseIsTablePersistentA(hdb, "_Tables");
4013     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4014
4015     cond = MsiDatabaseIsTablePersistentA(hdb, "_Columns");
4016     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4017
4018     cond = MsiDatabaseIsTablePersistentA(hdb, "_Storages");
4019     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4020
4021     cond = MsiDatabaseIsTablePersistentA(hdb, "_Streams");
4022     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4023
4024     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
4025     r = run_query(hdb, 0, query);
4026     ok(r == ERROR_SUCCESS, "failed to add table\n");
4027
4028     cond = MsiDatabaseIsTablePersistentA(hdb, "P");
4029     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4030
4031     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
4032     r = run_query(hdb, 0, query);
4033     ok(r == ERROR_SUCCESS, "failed to add table\n");
4034
4035     cond = MsiDatabaseIsTablePersistentA(hdb, "P2");
4036     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4037
4038     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4039     r = run_query(hdb, 0, query);
4040     ok(r == ERROR_SUCCESS, "failed to add table\n");
4041
4042     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4043     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4044
4045     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4046     r = run_query(hdb, 0, query);
4047     ok(r == ERROR_SUCCESS, "failed to add table\n");
4048
4049     query = "SELECT * FROM `T2`";
4050     r = MsiDatabaseOpenViewA(hdb, query, &view);
4051     ok(r == ERROR_BAD_QUERY_SYNTAX,
4052        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4053
4054     cond = MsiDatabaseIsTablePersistentA(hdb, "T2");
4055     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4056
4057     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
4058     r = run_query(hdb, 0, query);
4059     ok(r == ERROR_SUCCESS, "failed to add table\n");
4060
4061     cond = MsiDatabaseIsTablePersistentA(hdb, "T3");
4062     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
4063
4064     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
4065     r = run_query(hdb, 0, query);
4066     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
4067
4068     cond = MsiDatabaseIsTablePersistentA(hdb, "T4");
4069     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
4070
4071     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
4072     r = run_query(hdb, 0, query);
4073     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
4074
4075     query = "select * from `T`";
4076     r = MsiDatabaseOpenViewA(hdb, query, &view);
4077     ok(r == ERROR_SUCCESS, "failed to query table\n");
4078     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4079     ok(r == ERROR_SUCCESS, "failed to get column info\n");
4080
4081     sz = sizeof buf;
4082     r = MsiRecordGetStringA(rec, 1, buf, &sz);
4083     ok(r == ERROR_SUCCESS, "failed to get string\n");
4084     ok( 0 == strcmp("G255", buf), "wrong column type\n");
4085
4086     sz = sizeof buf;
4087     r = MsiRecordGetStringA(rec, 2, buf, &sz);
4088     ok(r == ERROR_SUCCESS, "failed to get string\n");
4089     ok( 0 == strcmp("j2", buf), "wrong column type\n");
4090
4091     MsiCloseHandle( rec );
4092     MsiViewClose( view );
4093     MsiCloseHandle( view );
4094
4095     /* query the table data */
4096     rec = 0;
4097     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
4098     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
4099     MsiCloseHandle( rec );
4100
4101     /* query the column data */
4102     rec = 0;
4103     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
4104     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4105     if (rec) MsiCloseHandle( rec );
4106
4107     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
4108     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
4109     if (rec) MsiCloseHandle( rec );
4110
4111     MsiCloseHandle( hdb );
4112     DeleteFileA(msifile);
4113 }
4114
4115 static void test_alter(void)
4116 {
4117     MSICONDITION cond;
4118     MSIHANDLE hdb = 0;
4119     const char *query;
4120     UINT r;
4121
4122     hdb = create_db();
4123     ok( hdb, "failed to create db\n");
4124
4125     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
4126     r = run_query(hdb, 0, query);
4127     ok(r == ERROR_SUCCESS, "failed to add table\n");
4128
4129     cond = MsiDatabaseIsTablePersistentA(hdb, "T");
4130     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
4131
4132     query = "ALTER TABLE `T` HOLD";
4133     r = run_query(hdb, 0, query);
4134     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
4135
4136     query = "ALTER TABLE `T` FREE";
4137     r = run_query(hdb, 0, query);
4138     ok(r == ERROR_SUCCESS, "failed to free table\n");
4139
4140     query = "ALTER TABLE `T` FREE";
4141     r = run_query(hdb, 0, query);
4142     ok(r == ERROR_SUCCESS, "failed to free table\n");
4143
4144     query = "ALTER TABLE `T` FREE";
4145     r = run_query(hdb, 0, query);
4146     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
4147
4148     query = "ALTER TABLE `T` HOLD";
4149     r = run_query(hdb, 0, query);
4150     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
4151
4152     /* table T is removed */
4153     query = "SELECT * FROM `T`";
4154     r = run_query(hdb, 0, query);
4155     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4156
4157     /* create the table again */
4158     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
4159     r = run_query(hdb, 0, query);
4160     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4161
4162     /* up the ref count */
4163     query = "ALTER TABLE `U` HOLD";
4164     r = run_query(hdb, 0, query);
4165     ok(r == ERROR_SUCCESS, "failed to free table\n");
4166
4167     /* add column, no data type */
4168     query = "ALTER TABLE `U` ADD `C`";
4169     r = run_query(hdb, 0, query);
4170     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4171
4172     query = "ALTER TABLE `U` ADD `C` INTEGER";
4173     r = run_query(hdb, 0, query);
4174     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4175
4176     /* add column C again */
4177     query = "ALTER TABLE `U` ADD `C` INTEGER";
4178     r = run_query(hdb, 0, query);
4179     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4180
4181     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
4182     r = run_query(hdb, 0, query);
4183     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4184
4185     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
4186     r = run_query(hdb, 0, query);
4187     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4188
4189     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
4190     r = run_query(hdb, 0, query);
4191     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4192
4193     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
4194     r = run_query(hdb, 0, query);
4195     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4196
4197     query = "SELECT * FROM `U` WHERE `D` = 8";
4198     r = run_query(hdb, 0, query);
4199     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4200
4201     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
4202     r = run_query(hdb, 0, query);
4203     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4204
4205     query = "ALTER COLUMN `D` FREE";
4206     r = run_query(hdb, 0, query);
4207     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4208
4209     /* drop the ref count */
4210     query = "ALTER TABLE `U` FREE";
4211     r = run_query(hdb, 0, query);
4212     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4213
4214     /* table is not empty */
4215     query = "SELECT * FROM `U`";
4216     r = run_query(hdb, 0, query);
4217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4218
4219     /* column D is removed */
4220     query = "SELECT * FROM `U` WHERE `D` = 8";
4221     r = run_query(hdb, 0, query);
4222     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4223
4224     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
4225     r = run_query(hdb, 0, query);
4226     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4227
4228     /* add the column again */
4229     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
4230     r = run_query(hdb, 0, query);
4231     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4232
4233     /* up the ref count */
4234     query = "ALTER TABLE `U` HOLD";
4235     r = run_query(hdb, 0, query);
4236     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4237
4238     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
4239     r = run_query(hdb, 0, query);
4240     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4241
4242     query = "SELECT * FROM `U` WHERE `E` = 16";
4243     r = run_query(hdb, 0, query);
4244     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4245
4246     /* drop the ref count */
4247     query = "ALTER TABLE `U` FREE";
4248     r = run_query(hdb, 0, query);
4249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4250
4251     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
4252     r = run_query(hdb, 0, query);
4253     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4254
4255     query = "SELECT * FROM `U` WHERE `E` = 20";
4256     r = run_query(hdb, 0, query);
4257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4258
4259     /* drop the ref count */
4260     query = "ALTER TABLE `U` FREE";
4261     r = run_query(hdb, 0, query);
4262     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4263
4264     /* table still exists */
4265     query = "SELECT * FROM `U`";
4266     r = run_query(hdb, 0, query);
4267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4268
4269     /* col E is removed */
4270     query = "SELECT * FROM `U` WHERE `E` = 20";
4271     r = run_query(hdb, 0, query);
4272     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4273
4274     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
4275     r = run_query(hdb, 0, query);
4276     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4277
4278     /* drop the ref count once more */
4279     query = "ALTER TABLE `U` FREE";
4280     r = run_query(hdb, 0, query);
4281     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4282
4283     /* table still exists */
4284     query = "SELECT * FROM `U`";
4285     r = run_query(hdb, 0, query);
4286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4287
4288     MsiCloseHandle( hdb );
4289     DeleteFileA(msifile);
4290 }
4291
4292 static void test_integers(void)
4293 {
4294     MSIHANDLE hdb = 0, view = 0, rec = 0;
4295     DWORD count, i;
4296     const char *query;
4297     UINT r;
4298
4299     /* just MsiOpenDatabase should not create a file */
4300     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4301     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4302
4303     /* create a table */
4304     query = "CREATE TABLE `integers` ( "
4305             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
4306             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
4307             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
4308             "PRIMARY KEY `one`)";
4309     r = MsiDatabaseOpenViewA(hdb, query, &view);
4310     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4311     r = MsiViewExecute(view, 0);
4312     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4313     r = MsiViewClose(view);
4314     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4315     r = MsiCloseHandle(view);
4316     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4317
4318     query = "SELECT * FROM `integers`";
4319     r = MsiDatabaseOpenViewA(hdb, query, &view);
4320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4321
4322     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
4323     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4324     count = MsiRecordGetFieldCount(rec);
4325     ok(count == 8, "Expected 8, got %d\n", count);
4326     ok(check_record(rec, 1, "one"), "Expected one\n");
4327     ok(check_record(rec, 2, "two"), "Expected two\n");
4328     ok(check_record(rec, 3, "three"), "Expected three\n");
4329     ok(check_record(rec, 4, "four"), "Expected four\n");
4330     ok(check_record(rec, 5, "five"), "Expected five\n");
4331     ok(check_record(rec, 6, "six"), "Expected six\n");
4332     ok(check_record(rec, 7, "seven"), "Expected seven\n");
4333     ok(check_record(rec, 8, "eight"), "Expected eight\n");
4334     MsiCloseHandle(rec);
4335
4336     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
4337     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4338     count = MsiRecordGetFieldCount(rec);
4339     ok(count == 8, "Expected 8, got %d\n", count);
4340     ok(check_record(rec, 1, "I2"), "Expected I2\n");
4341     ok(check_record(rec, 2, "I2"), "Expected I2\n");
4342     ok(check_record(rec, 3, "I2"), "Expected I2\n");
4343     ok(check_record(rec, 4, "I4"), "Expected I4\n");
4344     ok(check_record(rec, 5, "i2"), "Expected i2\n");
4345     ok(check_record(rec, 6, "i2"), "Expected i2\n");
4346     ok(check_record(rec, 7, "i2"), "Expected i2\n");
4347     ok(check_record(rec, 8, "i4"), "Expected i4\n");
4348     MsiCloseHandle(rec);
4349
4350     MsiViewClose(view);
4351     MsiCloseHandle(view);
4352
4353     /* insert values into it, NULL where NOT NULL is specified */
4354     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4355         "VALUES('', '', '', '', '', '', '', '')";
4356     r = MsiDatabaseOpenViewA(hdb, query, &view);
4357     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4358     r = MsiViewExecute(view, 0);
4359     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
4360
4361     MsiViewClose(view);
4362     MsiCloseHandle(view);
4363
4364     query = "SELECT * FROM `integers`";
4365     r = do_query(hdb, query, &rec);
4366     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4367
4368     r = MsiRecordGetFieldCount(rec);
4369     ok(r == -1, "record count wrong: %d\n", r);
4370
4371     MsiCloseHandle(rec);
4372
4373     /* insert legitimate values into it */
4374     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
4375         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
4376     r = MsiDatabaseOpenViewA(hdb, query, &view);
4377     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4378     r = MsiViewExecute(view, 0);
4379     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4380
4381     query = "SELECT * FROM `integers`";
4382     r = do_query(hdb, query, &rec);
4383     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4384
4385     r = MsiRecordGetFieldCount(rec);
4386     ok(r == 8, "record count wrong: %d\n", r);
4387
4388     i = MsiRecordGetInteger(rec, 1);
4389     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4390     i = MsiRecordGetInteger(rec, 3);
4391     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
4392     i = MsiRecordGetInteger(rec, 2);
4393     ok(i == 2, "Expected 2, got %d\n", i);
4394     i = MsiRecordGetInteger(rec, 4);
4395     ok(i == 4, "Expected 4, got %d\n", i);
4396     i = MsiRecordGetInteger(rec, 5);
4397     ok(i == 5, "Expected 5, got %d\n", i);
4398     i = MsiRecordGetInteger(rec, 6);
4399     ok(i == 6, "Expected 6, got %d\n", i);
4400     i = MsiRecordGetInteger(rec, 7);
4401     ok(i == 7, "Expected 7, got %d\n", i);
4402     i = MsiRecordGetInteger(rec, 8);
4403     ok(i == 8, "Expected 8, got %d\n", i);
4404
4405     MsiCloseHandle(rec);
4406     MsiViewClose(view);
4407     MsiCloseHandle(view);
4408
4409     r = MsiDatabaseCommit(hdb);
4410     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4411
4412     r = MsiCloseHandle(hdb);
4413     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4414
4415     r = DeleteFileA(msifile);
4416     ok(r == TRUE, "file didn't exist after commit\n");
4417 }
4418
4419 static void test_update(void)
4420 {
4421     MSIHANDLE hdb = 0, view = 0, rec = 0;
4422     CHAR result[MAX_PATH];
4423     const char *query;
4424     DWORD size;
4425     UINT r;
4426
4427     /* just MsiOpenDatabase should not create a file */
4428     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4429     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4430
4431     /* create the Control table */
4432     query = "CREATE TABLE `Control` ( "
4433         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
4434         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
4435         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
4436         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
4437     r = MsiDatabaseOpenViewA(hdb, query, &view);
4438     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4439     r = MsiViewExecute(view, 0);
4440     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4441     r = MsiViewClose(view);
4442     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4443     r = MsiCloseHandle(view);
4444     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4445
4446     /* add a control */
4447     query = "INSERT INTO `Control` ( "
4448         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4449         "`Property`, `Text`, `Control_Next`, `Help` )"
4450         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4451     r = MsiDatabaseOpenViewA(hdb, query, &view);
4452     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4453     r = MsiViewExecute(view, 0);
4454     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4455     r = MsiViewClose(view);
4456     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4457     r = MsiCloseHandle(view);
4458     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4459
4460     /* add a second control */
4461     query = "INSERT INTO `Control` ( "
4462         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4463         "`Property`, `Text`, `Control_Next`, `Help` )"
4464         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
4465     r = MsiDatabaseOpenViewA(hdb, query, &view);
4466     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4467     r = MsiViewExecute(view, 0);
4468     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4469     r = MsiViewClose(view);
4470     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4471     r = MsiCloseHandle(view);
4472     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4473
4474     /* add a third control */
4475     query = "INSERT INTO `Control` ( "
4476         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
4477         "`Property`, `Text`, `Control_Next`, `Help` )"
4478         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
4479     r = MsiDatabaseOpenViewA(hdb, query, &view);
4480     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4481     r = MsiViewExecute(view, 0);
4482     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4483     r = MsiViewClose(view);
4484     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4485     r = MsiCloseHandle(view);
4486     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4487
4488     /* bad table */
4489     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4490     r = MsiDatabaseOpenViewA(hdb, query, &view);
4491     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4492
4493     /* bad set column */
4494     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4495     r = MsiDatabaseOpenViewA(hdb, query, &view);
4496     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4497
4498     /* bad where condition */
4499     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
4500     r = MsiDatabaseOpenViewA(hdb, query, &view);
4501     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
4502
4503     /* just the dialog_ specified */
4504     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
4505     r = MsiDatabaseOpenViewA(hdb, query, &view);
4506     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4507     r = MsiViewExecute(view, 0);
4508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4509     r = MsiViewClose(view);
4510     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4511     r = MsiCloseHandle(view);
4512     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4513
4514     /* check the modified text */
4515     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4516     r = MsiDatabaseOpenViewA(hdb, query, &view);
4517     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4518     r = MsiViewExecute(view, 0);
4519     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4520
4521     r = MsiViewFetch(view, &rec);
4522     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4523
4524     size = MAX_PATH;
4525     r = MsiRecordGetStringA(rec, 1, result, &size);
4526     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4527     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4528
4529     MsiCloseHandle(rec);
4530
4531     r = MsiViewFetch(view, &rec);
4532     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4533
4534     size = MAX_PATH;
4535     r = MsiRecordGetStringA(rec, 1, result, &size);
4536     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4537     ok(!lstrlenA(result), "Expected an empty string, got %s\n", result);
4538
4539     MsiCloseHandle(rec);
4540
4541     r = MsiViewFetch(view, &rec);
4542     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4543
4544     r = MsiViewClose(view);
4545     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4546     r = MsiCloseHandle(view);
4547     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4548
4549     /* dialog_ and control specified */
4550     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
4551     r = MsiDatabaseOpenViewA(hdb, query, &view);
4552     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4553     r = MsiViewExecute(view, 0);
4554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4555     r = MsiViewClose(view);
4556     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4557     r = MsiCloseHandle(view);
4558     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4559
4560     /* check the modified text */
4561     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
4562     r = MsiDatabaseOpenViewA(hdb, query, &view);
4563     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4564     r = MsiViewExecute(view, 0);
4565     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4566
4567     r = MsiViewFetch(view, &rec);
4568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4569
4570     size = MAX_PATH;
4571     r = MsiRecordGetStringA(rec, 1, result, &size);
4572     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4573     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4574
4575     MsiCloseHandle(rec);
4576
4577     r = MsiViewFetch(view, &rec);
4578     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4579
4580     size = MAX_PATH;
4581     r = MsiRecordGetStringA(rec, 1, result, &size);
4582     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4583     ok(!lstrlenA(result), "Expected an empty string, got %s\n", result);
4584
4585     MsiCloseHandle(rec);
4586
4587     r = MsiViewFetch(view, &rec);
4588     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4589
4590     r = MsiViewClose(view);
4591     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4592     r = MsiCloseHandle(view);
4593     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4594
4595     /* no where condition */
4596     query = "UPDATE `Control` SET `Text` = 'this is text'";
4597     r = MsiDatabaseOpenViewA(hdb, query, &view);
4598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4599     r = MsiViewExecute(view, 0);
4600     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4601     r = MsiViewClose(view);
4602     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4603     r = MsiCloseHandle(view);
4604     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4605
4606     /* check the modified text */
4607     query = "SELECT `Text` FROM `Control`";
4608     r = MsiDatabaseOpenViewA(hdb, query, &view);
4609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4610     r = MsiViewExecute(view, 0);
4611     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4612
4613     r = MsiViewFetch(view, &rec);
4614     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4615
4616     size = MAX_PATH;
4617     r = MsiRecordGetStringA(rec, 1, result, &size);
4618     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4619     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4620
4621     MsiCloseHandle(rec);
4622
4623     r = MsiViewFetch(view, &rec);
4624     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4625
4626     size = MAX_PATH;
4627     r = MsiRecordGetStringA(rec, 1, result, &size);
4628     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4629     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4630
4631     MsiCloseHandle(rec);
4632
4633     r = MsiViewFetch(view, &rec);
4634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4635
4636     size = MAX_PATH;
4637     r = MsiRecordGetStringA(rec, 1, result, &size);
4638     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4639     ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
4640
4641     MsiCloseHandle(rec);
4642
4643     r = MsiViewFetch(view, &rec);
4644     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4645
4646     r = MsiViewClose(view);
4647     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4648     r = MsiCloseHandle(view);
4649     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4650
4651     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
4652         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
4653     r = run_query(hdb, 0, query);
4654     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4655
4656     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4657         "VALUES('one', 'two', 3)";
4658     r = run_query(hdb, 0, query);
4659     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4660
4661     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4662         "VALUES('three', 'four', 5)";
4663     r = run_query(hdb, 0, query);
4664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4665
4666     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
4667         "VALUES('six', 'two', 7)";
4668     r = run_query(hdb, 0, query);
4669     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4670
4671     rec = MsiCreateRecord(2);
4672     MsiRecordSetInteger(rec, 1, 8);
4673     MsiRecordSetStringA(rec, 2, "two");
4674
4675     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
4676     r = run_query(hdb, rec, query);
4677     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4678
4679     MsiCloseHandle(rec);
4680
4681     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
4682     r = MsiDatabaseOpenViewA(hdb, query, &view);
4683     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4684     r = MsiViewExecute(view, 0);
4685     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4686
4687     r = MsiViewFetch(view, &rec);
4688     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4689
4690     r = MsiRecordGetInteger(rec, 1);
4691     ok(r == 8, "Expected 8, got %d\n", r);
4692
4693     MsiCloseHandle(rec);
4694
4695     r = MsiViewFetch(view, &rec);
4696     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4697
4698     r = MsiRecordGetInteger(rec, 1);
4699     ok(r == 8, "Expected 8, got %d\n", r);
4700
4701     MsiCloseHandle(rec);
4702
4703     r = MsiViewFetch(view, &rec);
4704     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4705
4706     r = MsiRecordGetInteger(rec, 1);
4707     ok(r == 5, "Expected 5, got %d\n", r);
4708
4709     MsiCloseHandle(rec);
4710
4711     r = MsiViewFetch(view, &rec);
4712     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
4713
4714     MsiViewClose(view);
4715     MsiCloseHandle(view);
4716
4717     r = MsiDatabaseCommit(hdb);
4718     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
4719     r = MsiCloseHandle(hdb);
4720     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4721
4722     DeleteFileA(msifile);
4723 }
4724
4725 static void test_special_tables(void)
4726 {
4727     const char *query;
4728     MSIHANDLE hdb = 0;
4729     UINT r;
4730
4731     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4732     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4733
4734     query = "CREATE TABLE `_Properties` ( "
4735         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4736     r = run_query(hdb, 0, query);
4737     ok(r == ERROR_SUCCESS, "failed to create table\n");
4738
4739     query = "CREATE TABLE `_Storages` ( "
4740         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4741     r = run_query(hdb, 0, query);
4742     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4743
4744     query = "CREATE TABLE `_Streams` ( "
4745         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4746     r = run_query(hdb, 0, query);
4747     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
4748
4749     query = "CREATE TABLE `_Tables` ( "
4750         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4751     r = run_query(hdb, 0, query);
4752     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
4753
4754     query = "CREATE TABLE `_Columns` ( "
4755         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
4756     r = run_query(hdb, 0, query);
4757     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
4758
4759     r = MsiCloseHandle(hdb);
4760     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4761 }
4762
4763 static void test_tables_order(void)
4764 {
4765     const char *query;
4766     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4767     UINT r;
4768     char buffer[100];
4769     DWORD sz;
4770
4771     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4772     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4773
4774     query = "CREATE TABLE `foo` ( "
4775         "`baz` INT NOT NULL PRIMARY KEY `baz`)";
4776     r = run_query(hdb, 0, query);
4777     ok(r == ERROR_SUCCESS, "failed to create table\n");
4778
4779     query = "CREATE TABLE `bar` ( "
4780         "`foo` INT NOT NULL PRIMARY KEY `foo`)";
4781     r = run_query(hdb, 0, query);
4782     ok(r == ERROR_SUCCESS, "failed to create table\n");
4783
4784     query = "CREATE TABLE `baz` ( "
4785         "`bar` INT NOT NULL, "
4786         "`baz` INT NOT NULL, "
4787         "`foo` INT NOT NULL PRIMARY KEY `bar`)";
4788     r = run_query(hdb, 0, query);
4789     ok(r == ERROR_SUCCESS, "failed to create table\n");
4790
4791     /* The names of the tables in the _Tables table must
4792        be in the same order as these names are created in
4793        the strings table. */
4794     query = "SELECT * FROM `_Tables`";
4795     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4796     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4797     r = MsiViewExecute(hview, 0);
4798     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4799
4800     r = MsiViewFetch(hview, &hrec);
4801     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4802     sz = sizeof(buffer);
4803     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4804     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4805     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4806     r = MsiCloseHandle(hrec);
4807     ok(r == ERROR_SUCCESS, "failed to close record\n");
4808
4809     r = MsiViewFetch(hview, &hrec);
4810     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4811     sz = sizeof(buffer);
4812     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4813     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4814     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4815     r = MsiCloseHandle(hrec);
4816     ok(r == ERROR_SUCCESS, "failed to close record\n");
4817
4818     r = MsiViewFetch(hview, &hrec);
4819     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4820     sz = sizeof(buffer);
4821     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4822     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4823     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4824     r = MsiCloseHandle(hrec);
4825     ok(r == ERROR_SUCCESS, "failed to close record\n");
4826
4827     r = MsiViewClose(hview);
4828     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4829     r = MsiCloseHandle(hview);
4830     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4831
4832     /* The names of the tables in the _Columns table must
4833        be in the same order as these names are created in
4834        the strings table. */
4835     query = "SELECT * FROM `_Columns`";
4836     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4837     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4838     r = MsiViewExecute(hview, 0);
4839     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4840
4841     r = MsiViewFetch(hview, &hrec);
4842     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4843     sz = sizeof(buffer);
4844     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4845     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4846     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4847     sz = sizeof(buffer);
4848     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4850     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4851     r = MsiCloseHandle(hrec);
4852     ok(r == ERROR_SUCCESS, "failed to close record\n");
4853
4854     r = MsiViewFetch(hview, &hrec);
4855     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4856     sz = sizeof(buffer);
4857     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4859     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4860     sz = sizeof(buffer);
4861     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4863     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4864     r = MsiCloseHandle(hrec);
4865     ok(r == ERROR_SUCCESS, "failed to close record\n");
4866
4867     r = MsiViewFetch(hview, &hrec);
4868     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4869     sz = sizeof(buffer);
4870     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4871     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4872     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4873     sz = sizeof(buffer);
4874     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4875     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4876     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4877     r = MsiCloseHandle(hrec);
4878     ok(r == ERROR_SUCCESS, "failed to close record\n");
4879
4880     r = MsiViewFetch(hview, &hrec);
4881     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4882     sz = sizeof(buffer);
4883     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4885     ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
4886     sz = sizeof(buffer);
4887     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4888     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4889     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4890     r = MsiCloseHandle(hrec);
4891     ok(r == ERROR_SUCCESS, "failed to close record\n");
4892
4893     r = MsiViewFetch(hview, &hrec);
4894     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4895     sz = sizeof(buffer);
4896     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4898     ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
4899     sz = sizeof(buffer);
4900     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
4901     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4902     ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
4903     r = MsiCloseHandle(hrec);
4904     ok(r == ERROR_SUCCESS, "failed to close record\n");
4905
4906     r = MsiViewClose(hview);
4907     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4908     r = MsiCloseHandle(hview);
4909     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4910
4911     r = MsiCloseHandle(hdb);
4912     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4913
4914     DeleteFileA(msifile);
4915 }
4916
4917 static void test_rows_order(void)
4918 {
4919     const char *query;
4920     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4921     UINT r;
4922     char buffer[100];
4923     DWORD sz;
4924
4925     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
4926     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4927
4928     query = "CREATE TABLE `foo` ( "
4929         "`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
4930     r = run_query(hdb, 0, query);
4931     ok(r == ERROR_SUCCESS, "failed to create table\n");
4932
4933     r = run_query(hdb, 0, "INSERT INTO `foo` "
4934             "( `bar` ) VALUES ( 'A' )");
4935     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4936
4937     r = run_query(hdb, 0, "INSERT INTO `foo` "
4938             "( `bar` ) VALUES ( 'B' )");
4939     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4940
4941     r = run_query(hdb, 0, "INSERT INTO `foo` "
4942             "( `bar` ) VALUES ( 'C' )");
4943     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4944
4945     r = run_query(hdb, 0, "INSERT INTO `foo` "
4946             "( `bar` ) VALUES ( 'D' )");
4947     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4948
4949     r = run_query(hdb, 0, "INSERT INTO `foo` "
4950             "( `bar` ) VALUES ( 'E' )");
4951     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4952
4953     r = run_query(hdb, 0, "INSERT INTO `foo` "
4954             "( `bar` ) VALUES ( 'F' )");
4955     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4956
4957     query = "CREATE TABLE `bar` ( "
4958         "`foo` LONGCHAR NOT NULL, "
4959         "`baz` LONGCHAR NOT NULL "
4960         "PRIMARY KEY `foo` )";
4961     r = run_query(hdb, 0, query);
4962     ok(r == ERROR_SUCCESS, "failed to create table\n");
4963
4964     r = run_query(hdb, 0, "INSERT INTO `bar` "
4965             "( `foo`, `baz` ) VALUES ( 'C', 'E' )");
4966     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4967
4968     r = run_query(hdb, 0, "INSERT INTO `bar` "
4969             "( `foo`, `baz` ) VALUES ( 'F', 'A' )");
4970     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4971
4972     r = run_query(hdb, 0, "INSERT INTO `bar` "
4973             "( `foo`, `baz` ) VALUES ( 'A', 'B' )");
4974     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4975
4976     r = run_query(hdb, 0, "INSERT INTO `bar` "
4977             "( `foo`, `baz` ) VALUES ( 'D', 'E' )");
4978     ok(r == ERROR_SUCCESS, "cannot add value to table\n");
4979
4980     /* The rows of the table must be ordered by the column values of
4981        each row. For strings, the column value is the string id
4982        in the string table.  */
4983
4984     query = "SELECT * FROM `bar`";
4985     r = MsiDatabaseOpenViewA(hdb, query, &hview);
4986     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4987     r = MsiViewExecute(hview, 0);
4988     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4989
4990     r = MsiViewFetch(hview, &hrec);
4991     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4992     sz = sizeof(buffer);
4993     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
4994     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4995     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
4996     sz = sizeof(buffer);
4997     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
4998     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4999     ok(!lstrcmpA(buffer, "B"), "Expected B, got %s\n", buffer);
5000     r = MsiCloseHandle(hrec);
5001     ok(r == ERROR_SUCCESS, "failed to close record\n");
5002
5003     r = MsiViewFetch(hview, &hrec);
5004     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5005     sz = sizeof(buffer);
5006     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5007     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5008     ok(!lstrcmpA(buffer, "C"), "Expected E, got %s\n", buffer);
5009     sz = sizeof(buffer);
5010     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5011     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5012     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5013     r = MsiCloseHandle(hrec);
5014     ok(r == ERROR_SUCCESS, "failed to close record\n");
5015
5016     r = MsiViewFetch(hview, &hrec);
5017     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5018     sz = sizeof(buffer);
5019     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5020     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5021     ok(!lstrcmpA(buffer, "D"), "Expected D, got %s\n", buffer);
5022     sz = sizeof(buffer);
5023     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5025     ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
5026     r = MsiCloseHandle(hrec);
5027     ok(r == ERROR_SUCCESS, "failed to close record\n");
5028
5029     r = MsiViewFetch(hview, &hrec);
5030     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5031     sz = sizeof(buffer);
5032     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5034     ok(!lstrcmpA(buffer, "F"), "Expected F, got %s\n", buffer);
5035     sz = sizeof(buffer);
5036     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5037     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5038     ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
5039     r = MsiCloseHandle(hrec);
5040     ok(r == ERROR_SUCCESS, "failed to close record\n");
5041
5042     r = MsiViewClose(hview);
5043     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5044     r = MsiCloseHandle(hview);
5045     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5046
5047     r = MsiCloseHandle(hdb);
5048     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5049
5050     DeleteFileA(msifile);
5051 }
5052
5053 static void test_collation(void)
5054 {
5055     static const WCHAR query1[] =
5056         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5057          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5058          '(','\'','a',0x30a,'\'',',','\'','C','\'',')',0};
5059     static const WCHAR query2[] =
5060         {'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
5061          '(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
5062          '(','\'',0xe5,'\'',',','\'','D','\'',')',0};
5063     static const WCHAR query3[] =
5064         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','b','a','z','`',' ',
5065          '(',' ','`','a',0x30a,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',',',
5066            ' ','`',0xe5,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',' ',
5067            'P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','a',0x30a,'`',')',0};
5068     static const WCHAR query4[] =
5069         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','a',0x30a,'`',' ',
5070          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5071          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5072     static const WCHAR query5[] =
5073         {'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`',0xe5,'`',' ',
5074          '(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
5075          'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
5076     static const WCHAR query6[] =
5077         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','b','a','r','`',' ','W','H','E','R','E',
5078          ' ','`','f','o','o','`',' ','=','\'',0xe5,'\'',0};
5079     static const WCHAR letter_C[] = {'C',0};
5080     static const WCHAR letter_D[] = {'D',0};
5081     static const WCHAR letter_a_ring[] = {'a',0x30a,0};
5082     static const WCHAR letter_a_with_ring[] = {0xe5,0};
5083     const char *query;
5084     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5085     UINT r;
5086     char buffer[100];
5087     WCHAR bufferW[100];
5088     DWORD sz;
5089
5090     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5091     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5092
5093     query = "CREATE TABLE `bar` ( "
5094         "`foo` LONGCHAR NOT NULL, "
5095         "`baz` LONGCHAR NOT NULL "
5096         "PRIMARY KEY `foo` )";
5097     r = run_query(hdb, 0, query);
5098     ok(r == ERROR_SUCCESS, "failed to create table\n");
5099
5100     r = run_query(hdb, 0, query);
5101     ok(r == ERROR_BAD_QUERY_SYNTAX, "wrong error %u\n", r);
5102
5103     r = run_query(hdb, 0, "INSERT INTO `bar` "
5104             "( `foo`, `baz` ) VALUES ( '\2', 'A' )");
5105     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5106
5107     r = run_query(hdb, 0, "INSERT INTO `bar` "
5108             "( `foo`, `baz` ) VALUES ( '\1', 'B' )");
5109     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5110
5111     r = run_queryW(hdb, 0, query1);
5112     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5113
5114     r = run_queryW(hdb, 0, query2);
5115     ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
5116
5117     r = run_queryW(hdb, 0, query3);
5118     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5119
5120     r = run_queryW(hdb, 0, query4);
5121     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5122
5123     r = run_queryW(hdb, 0, query5);
5124     ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
5125
5126     query = "SELECT * FROM `bar`";
5127     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5128     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5129     r = MsiViewExecute(hview, 0);
5130     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5131
5132     r = MsiViewFetch(hview, &hrec);
5133     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5134     sz = sizeof(buffer);
5135     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5136     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5137     ok(!lstrcmpA(buffer, "\2"), "Expected \\2, got '%s'\n", buffer);
5138     sz = sizeof(buffer);
5139     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5140     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5141     ok(!lstrcmpA(buffer, "A"), "Expected A, got '%s'\n", buffer);
5142     MsiCloseHandle(hrec);
5143
5144     r = MsiViewFetch(hview, &hrec);
5145     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5146     sz = sizeof(buffer);
5147     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
5148     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5149     ok(!lstrcmpA(buffer, "\1"), "Expected \\1, got '%s'\n", buffer);
5150     sz = sizeof(buffer);
5151     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5152     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5153     ok(!lstrcmpA(buffer, "B"), "Expected B, got '%s'\n", buffer);
5154     MsiCloseHandle(hrec);
5155
5156     r = MsiViewFetch(hview, &hrec);
5157     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5158     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5159     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5160     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5161     ok(!memcmp(bufferW, letter_a_ring, sizeof(letter_a_ring)),
5162        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_ring), wine_dbgstr_w(bufferW));
5163     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5164     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5165     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5166     ok(!lstrcmpW(bufferW, letter_C), "Expected C, got %s\n", wine_dbgstr_w(bufferW));
5167     MsiCloseHandle(hrec);
5168
5169     r = MsiViewFetch(hview, &hrec);
5170     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5171     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5172     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5173     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5174     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5175        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5176     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5177     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5178     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5179     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5180     MsiCloseHandle(hrec);
5181
5182     r = MsiViewClose(hview);
5183     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5184     r = MsiCloseHandle(hview);
5185     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5186
5187     r = MsiDatabaseOpenViewW(hdb, query6, &hview);
5188     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5189     r = MsiViewExecute(hview, 0);
5190     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5191
5192     r = MsiViewFetch(hview, &hrec);
5193     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5194     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5195     r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
5196     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5197     ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
5198        "Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
5199     sz = sizeof(bufferW) / sizeof(bufferW[0]);
5200     r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
5201     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5202     ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
5203     MsiCloseHandle(hrec);
5204
5205     r = MsiViewFetch(hview, &hrec);
5206     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
5207
5208     r = MsiViewClose(hview);
5209     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5210     r = MsiCloseHandle(hview);
5211     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5212
5213     r = MsiCloseHandle(hdb);
5214     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5215
5216     DeleteFileA(msifile);
5217 }
5218
5219 static void test_select_markers(void)
5220 {
5221     MSIHANDLE hdb = 0, rec, view, res;
5222     LPCSTR query;
5223     UINT r;
5224     DWORD size;
5225     CHAR buf[MAX_PATH];
5226
5227     hdb = create_db();
5228     ok( hdb, "failed to create db\n");
5229
5230     r = run_query(hdb, 0,
5231             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
5232     ok(r == S_OK, "cannot create table: %d\n", r);
5233
5234     r = run_query(hdb, 0, "INSERT INTO `Table` "
5235             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
5236     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5237
5238     r = run_query(hdb, 0, "INSERT INTO `Table` "
5239             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
5240     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5241
5242     r = run_query(hdb, 0, "INSERT INTO `Table` "
5243             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
5244     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5245
5246     r = run_query(hdb, 0, "INSERT INTO `Table` "
5247             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
5248     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
5249
5250     rec = MsiCreateRecord(2);
5251     MsiRecordSetStringA(rec, 1, "apple");
5252     MsiRecordSetStringA(rec, 2, "two");
5253
5254     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
5255     r = MsiDatabaseOpenViewA(hdb, query, &view);
5256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5257
5258     r = MsiViewExecute(view, rec);
5259     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5260
5261     r = MsiViewFetch(view, &res);
5262     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5263
5264     size = MAX_PATH;
5265     r = MsiRecordGetStringA(res, 1, buf, &size);
5266     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5267     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5268
5269     size = MAX_PATH;
5270     r = MsiRecordGetStringA(res, 2, buf, &size);
5271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5272     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5273
5274     r = MsiRecordGetInteger(res, 3);
5275     ok(r == 1, "Expected 1, got %d\n", r);
5276
5277     MsiCloseHandle(res);
5278
5279     r = MsiViewFetch(view, &res);
5280     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5281
5282     size = MAX_PATH;
5283     r = MsiRecordGetStringA(res, 1, buf, &size);
5284     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5285     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5286
5287     size = MAX_PATH;
5288     r = MsiRecordGetStringA(res, 2, buf, &size);
5289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5290     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5291
5292     r = MsiRecordGetInteger(res, 3);
5293     ok(r == 2, "Expected 2, got %d\n", r);
5294
5295     MsiCloseHandle(res);
5296
5297     r = MsiViewFetch(view, &res);
5298     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5299
5300     MsiCloseHandle(rec);
5301     MsiViewClose(view);
5302     MsiCloseHandle(view);
5303
5304     rec = MsiCreateRecord(2);
5305     MsiRecordSetStringA(rec, 1, "one");
5306     MsiRecordSetInteger(rec, 2, 1);
5307
5308     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
5309     r = MsiDatabaseOpenViewA(hdb, query, &view);
5310     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5311     r = MsiViewExecute(view, rec);
5312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5313
5314     r = MsiViewFetch(view, &res);
5315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5316
5317     size = MAX_PATH;
5318     r = MsiRecordGetStringA(res, 1, buf, &size);
5319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5320     ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
5321
5322     size = MAX_PATH;
5323     r = MsiRecordGetStringA(res, 2, buf, &size);
5324     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5325     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5326
5327     r = MsiRecordGetInteger(res, 3);
5328     ok(r == 2, "Expected 2, got %d\n", r);
5329
5330     MsiCloseHandle(res);
5331
5332     r = MsiViewFetch(view, &res);
5333     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5334
5335     size = MAX_PATH;
5336     r = MsiRecordGetStringA(res, 1, buf, &size);
5337     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5338     ok(!lstrcmpA(buf, "banana"), "Expected banana, got %s\n", buf);
5339
5340     size = MAX_PATH;
5341     r = MsiRecordGetStringA(res, 2, buf, &size);
5342     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5343     ok(!lstrcmpA(buf, "three"), "Expected three, got %s\n", buf);
5344
5345     r = MsiRecordGetInteger(res, 3);
5346     ok(r == 3, "Expected 3, got %d\n", r);
5347
5348     MsiCloseHandle(res);
5349
5350     r = MsiViewFetch(view, &res);
5351     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5352
5353     MsiCloseHandle(rec);
5354     MsiViewClose(view);
5355     MsiCloseHandle(view);
5356     MsiCloseHandle(hdb);
5357     DeleteFileA(msifile);
5358 }
5359
5360 static void test_viewmodify_update(void)
5361 {
5362     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5363     UINT i, test_max, offset, count;
5364     const char *query;
5365     UINT r;
5366
5367     DeleteFileA(msifile);
5368
5369     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5370     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5371
5372     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5373     r = run_query( hdb, 0, query );
5374     ok(r == ERROR_SUCCESS, "query failed\n");
5375
5376     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
5377     r = run_query( hdb, 0, query );
5378     ok(r == ERROR_SUCCESS, "query failed\n");
5379
5380     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
5381     r = run_query( hdb, 0, query );
5382     ok(r == ERROR_SUCCESS, "query failed\n");
5383
5384     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
5385     r = run_query( hdb, 0, query );
5386     ok(r == ERROR_SUCCESS, "query failed\n");
5387
5388     query = "SELECT `B` FROM `table`";
5389     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5390     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5391     r = MsiViewExecute(hview, 0);
5392     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5393     r = MsiViewFetch(hview, &hrec);
5394     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5395
5396     r = MsiRecordSetInteger(hrec, 1, 0);
5397     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5398
5399     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5400     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5401
5402     r = MsiCloseHandle(hrec);
5403     ok(r == ERROR_SUCCESS, "failed to close record\n");
5404
5405     r = MsiViewClose(hview);
5406     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5407     r = MsiCloseHandle(hview);
5408     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5409
5410     query = "SELECT * FROM `table`";
5411     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5412     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5413     r = MsiViewExecute(hview, 0);
5414     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5415     r = MsiViewFetch(hview, &hrec);
5416     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5417
5418     r = MsiRecordGetInteger(hrec, 1);
5419     ok(r == 1, "Expected 1, got %d\n", r);
5420     r = MsiRecordGetInteger(hrec, 2);
5421     ok(r == 0, "Expected 0, got %d\n", r);
5422
5423     r = MsiCloseHandle(hrec);
5424     ok(r == ERROR_SUCCESS, "failed to close record\n");
5425
5426     r = MsiViewFetch(hview, &hrec);
5427     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5428
5429     r = MsiRecordGetInteger(hrec, 1);
5430     ok(r == 3, "Expected 3, got %d\n", r);
5431     r = MsiRecordGetInteger(hrec, 2);
5432     ok(r == 4, "Expected 4, got %d\n", r);
5433
5434     r = MsiCloseHandle(hrec);
5435     ok(r == ERROR_SUCCESS, "failed to close record\n");
5436
5437     r = MsiViewFetch(hview, &hrec);
5438     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5439
5440     r = MsiRecordGetInteger(hrec, 1);
5441     ok(r == 5, "Expected 5, got %d\n", r);
5442     r = MsiRecordGetInteger(hrec, 2);
5443     ok(r == 6, "Expected 6, got %d\n", r);
5444
5445     r = MsiCloseHandle(hrec);
5446     ok(r == ERROR_SUCCESS, "failed to close record\n");
5447
5448     r = MsiViewFetch(hview, &hrec);
5449     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5450
5451     r = MsiViewClose(hview);
5452     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5453     r = MsiCloseHandle(hview);
5454     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5455
5456     /* loop through all elements */
5457     query = "SELECT `B` FROM `table`";
5458     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5459     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5460     r = MsiViewExecute(hview, 0);
5461     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5462
5463     while (TRUE)
5464     {
5465         r = MsiViewFetch(hview, &hrec);
5466         if (r != ERROR_SUCCESS)
5467             break;
5468
5469         r = MsiRecordSetInteger(hrec, 1, 0);
5470         ok(r == ERROR_SUCCESS, "failed to set integer\n");
5471
5472         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5473         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5474
5475         r = MsiCloseHandle(hrec);
5476         ok(r == ERROR_SUCCESS, "failed to close record\n");
5477     }
5478
5479     r = MsiViewClose(hview);
5480     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5481     r = MsiCloseHandle(hview);
5482     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5483
5484     query = "SELECT * FROM `table`";
5485     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5486     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5487     r = MsiViewExecute(hview, 0);
5488     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5489     r = MsiViewFetch(hview, &hrec);
5490     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5491
5492     r = MsiRecordGetInteger(hrec, 1);
5493     ok(r == 1, "Expected 1, got %d\n", r);
5494     r = MsiRecordGetInteger(hrec, 2);
5495     ok(r == 0, "Expected 0, got %d\n", r);
5496
5497     r = MsiCloseHandle(hrec);
5498     ok(r == ERROR_SUCCESS, "failed to close record\n");
5499
5500     r = MsiViewFetch(hview, &hrec);
5501     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5502
5503     r = MsiRecordGetInteger(hrec, 1);
5504     ok(r == 3, "Expected 3, got %d\n", r);
5505     r = MsiRecordGetInteger(hrec, 2);
5506     ok(r == 0, "Expected 0, got %d\n", r);
5507
5508     r = MsiCloseHandle(hrec);
5509     ok(r == ERROR_SUCCESS, "failed to close record\n");
5510
5511     r = MsiViewFetch(hview, &hrec);
5512     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5513
5514     r = MsiRecordGetInteger(hrec, 1);
5515     ok(r == 5, "Expected 5, got %d\n", r);
5516     r = MsiRecordGetInteger(hrec, 2);
5517     ok(r == 0, "Expected 0, got %d\n", r);
5518
5519     r = MsiCloseHandle(hrec);
5520     ok(r == ERROR_SUCCESS, "failed to close record\n");
5521
5522     r = MsiViewFetch(hview, &hrec);
5523     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5524
5525     r = MsiViewClose(hview);
5526     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5527     r = MsiCloseHandle(hview);
5528     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5529
5530     query = "CREATE TABLE `table2` (`A` INT, `B` INT PRIMARY KEY `A`)";
5531     r = run_query( hdb, 0, query );
5532     ok(r == ERROR_SUCCESS, "query failed\n");
5533
5534     query = "INSERT INTO `table2` (`A`, `B`) VALUES (?, ?)";
5535     r = MsiDatabaseOpenViewA( hdb, query, &hview );
5536     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5537
5538     test_max = 100;
5539     offset = 1234;
5540     for(i = 0; i < test_max; i++)
5541     {
5542
5543         hrec = MsiCreateRecord( 2 );
5544         MsiRecordSetInteger( hrec, 1, test_max - i );
5545         MsiRecordSetInteger( hrec, 2, i );
5546
5547         r = MsiViewExecute( hview, hrec );
5548         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5549
5550         r = MsiCloseHandle( hrec );
5551         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5552     }
5553
5554     r = MsiViewClose( hview );
5555     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5556     r = MsiCloseHandle( hview );
5557     ok(r == ERROR_SUCCESS, "Got %d\n", r);
5558
5559     /* Update. */
5560     query = "SELECT * FROM `table2` ORDER BY `B`";
5561     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5562     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5563     r = MsiViewExecute( hview, 0 );
5564     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5565
5566     count = 0;
5567     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5568     {
5569         UINT b = MsiRecordGetInteger( hrec, 2 );
5570
5571         r = MsiRecordSetInteger( hrec, 2, b + offset);
5572         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5573
5574         r = MsiViewModify( hview, MSIMODIFY_UPDATE, hrec );
5575         ok(r == ERROR_SUCCESS, "Got %d\n", r);
5576
5577         r = MsiCloseHandle(hrec);
5578         ok(r == ERROR_SUCCESS, "failed to close record\n");
5579         count++;
5580     }
5581     ok(count == test_max, "Got count %d\n", count);
5582
5583     r = MsiViewClose(hview);
5584     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5585     r = MsiCloseHandle(hview);
5586     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5587
5588     /* Recheck. */
5589     query = "SELECT * FROM `table2` ORDER BY `B`";
5590     r = MsiDatabaseOpenViewA( hdb, query, &hview);
5591     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5592     r = MsiViewExecute( hview, 0 );
5593     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5594
5595     count = 0;
5596     while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
5597     {
5598         UINT a = MsiRecordGetInteger( hrec, 1 );
5599         UINT b = MsiRecordGetInteger( hrec, 2 );
5600         ok( ( test_max - a + offset) == b, "Got (%d, %d), expected (%d, %d)\n",
5601             a, b, test_max - a + offset, b);
5602
5603         r = MsiCloseHandle(hrec);
5604         ok(r == ERROR_SUCCESS, "failed to close record\n");
5605         count++;
5606     }
5607     ok(count == test_max, "Got count %d\n", count);
5608
5609     r = MsiViewClose(hview);
5610     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5611     r = MsiCloseHandle(hview);
5612     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5613
5614     r = MsiCloseHandle( hdb );
5615     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5616 }
5617
5618 static void test_viewmodify_assign(void)
5619 {
5620     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5621     const char *query;
5622     UINT r;
5623
5624     /* setup database */
5625     DeleteFileA(msifile);
5626
5627     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5628     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
5629
5630     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
5631     r = run_query( hdb, 0, query );
5632     ok(r == ERROR_SUCCESS, "query failed\n");
5633
5634     /* assign to view, new primary key */
5635     query = "SELECT * FROM `table`";
5636     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5637     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5638     r = MsiViewExecute(hview, 0);
5639     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5640
5641     hrec = MsiCreateRecord(2);
5642     ok(hrec != 0, "MsiCreateRecord failed\n");
5643
5644     r = MsiRecordSetInteger(hrec, 1, 1);
5645     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5646     r = MsiRecordSetInteger(hrec, 2, 2);
5647     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5648
5649     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5650     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5651
5652     r = MsiCloseHandle(hrec);
5653     ok(r == ERROR_SUCCESS, "failed to close record\n");
5654
5655     r = MsiViewClose(hview);
5656     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5657     r = MsiCloseHandle(hview);
5658     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5659
5660     query = "SELECT * FROM `table`";
5661     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5662     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5663     r = MsiViewExecute(hview, 0);
5664     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5665     r = MsiViewFetch(hview, &hrec);
5666     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5667
5668     r = MsiRecordGetInteger(hrec, 1);
5669     ok(r == 1, "Expected 1, got %d\n", r);
5670     r = MsiRecordGetInteger(hrec, 2);
5671     ok(r == 2, "Expected 2, got %d\n", r);
5672
5673     r = MsiCloseHandle(hrec);
5674     ok(r == ERROR_SUCCESS, "failed to close record\n");
5675
5676     r = MsiViewFetch(hview, &hrec);
5677     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5678
5679     r = MsiViewClose(hview);
5680     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5681     r = MsiCloseHandle(hview);
5682     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5683
5684     /* assign to view, primary key matches */
5685     query = "SELECT * FROM `table`";
5686     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5687     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5688     r = MsiViewExecute(hview, 0);
5689     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5690
5691     hrec = MsiCreateRecord(2);
5692     ok(hrec != 0, "MsiCreateRecord failed\n");
5693
5694     r = MsiRecordSetInteger(hrec, 1, 1);
5695     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5696     r = MsiRecordSetInteger(hrec, 2, 4);
5697     ok(r == ERROR_SUCCESS, "failed to set integer\n");
5698
5699     r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
5700     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
5701
5702     r = MsiCloseHandle(hrec);
5703     ok(r == ERROR_SUCCESS, "failed to close record\n");
5704
5705     r = MsiViewClose(hview);
5706     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5707     r = MsiCloseHandle(hview);
5708     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5709
5710     query = "SELECT * FROM `table`";
5711     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5712     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
5713     r = MsiViewExecute(hview, 0);
5714     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
5715     r = MsiViewFetch(hview, &hrec);
5716     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
5717
5718     r = MsiRecordGetInteger(hrec, 1);
5719     ok(r == 1, "Expected 1, got %d\n", r);
5720     r = MsiRecordGetInteger(hrec, 2);
5721     ok(r == 4, "Expected 4, got %d\n", r);
5722
5723     r = MsiCloseHandle(hrec);
5724     ok(r == ERROR_SUCCESS, "failed to close record\n");
5725
5726     r = MsiViewFetch(hview, &hrec);
5727     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5728
5729     r = MsiViewClose(hview);
5730     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
5731     r = MsiCloseHandle(hview);
5732     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
5733
5734     /* close database */
5735     r = MsiCloseHandle( hdb );
5736     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
5737 }
5738
5739 static const WCHAR data10[] = { /* MOO */
5740     0x8001, 0x000b,
5741 };
5742 static const WCHAR data11[] = { /* AAR */
5743     0x8002, 0x8005,
5744     0x000c, 0x000f,
5745 };
5746 static const char data12[] = /* _StringData */
5747     "MOOABAARCDonetwofourfive";
5748 static const WCHAR data13[] = { /* _StringPool */
5749 /*  len, refs */
5750     0,   0,    /* string 0 ''     */
5751     0,   0,    /* string 1 ''     */
5752     0,   0,    /* string 2 ''     */
5753     0,   0,    /* string 3 ''     */
5754     0,   0,    /* string 4 ''     */
5755     3,   3,    /* string 5 'MOO'  */
5756     1,   1,    /* string 6 'A'    */
5757     1,   1,    /* string 7 'B'    */
5758     3,   3,    /* string 8 'AAR'  */
5759     1,   1,    /* string 9 'C'    */
5760     1,   1,    /* string a 'D'    */
5761     3,   1,    /* string b 'one'  */
5762     3,   1,    /* string c 'two'  */
5763     0,   0,    /* string d ''     */
5764     4,   1,    /* string e 'four' */
5765     4,   1,    /* string f 'five' */
5766 };
5767
5768 static void test_stringtable(void)
5769 {
5770     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
5771     IStorage *stg = NULL;
5772     IStream *stm;
5773     WCHAR name[0x20];
5774     HRESULT hr;
5775     const char *query;
5776     char buffer[MAX_PATH];
5777     WCHAR data[MAX_PATH];
5778     DWORD sz, read;
5779     UINT r;
5780
5781     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
5782     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
5783     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
5784     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
5785     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
5786
5787     DeleteFileA(msifile);
5788
5789     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
5790     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5791
5792     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
5793     r = run_query(hdb, 0, query);
5794     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5795
5796     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
5797     r = run_query(hdb, 0, query);
5798     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5799
5800     /* insert persistent row */
5801     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
5802     r = run_query(hdb, 0, query);
5803     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5804
5805     /* insert persistent row */
5806     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
5807     r = run_query(hdb, 0, query);
5808     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5809
5810     /* open a view */
5811     query = "SELECT * FROM `MOO`";
5812     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5813     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5814     r = MsiViewExecute(hview, 0);
5815     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5816
5817     hrec = MsiCreateRecord(2);
5818
5819     r = MsiRecordSetInteger(hrec, 1, 3);
5820     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5821     r = MsiRecordSetStringA(hrec, 2, "three");
5822     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5823
5824     /* insert a nonpersistent row */
5825     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5826     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5827
5828     r = MsiCloseHandle(hrec);
5829     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5830     r = MsiViewClose(hview);
5831     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5832     r = MsiCloseHandle(hview);
5833     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5834
5835     /* insert persistent row */
5836     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
5837     r = run_query(hdb, 0, query);
5838     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5839
5840     /* insert persistent row */
5841     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
5842     r = run_query(hdb, 0, query);
5843     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5844
5845     r = MsiDatabaseCommit(hdb);
5846     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5847
5848     r = MsiCloseHandle(hdb);
5849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5850
5851     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
5852     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5853
5854     query = "SELECT * FROM `MOO`";
5855     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5856     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5857
5858     r = MsiViewExecute(hview, 0);
5859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5860
5861     r = MsiViewFetch(hview, &hrec);
5862     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5863
5864     r = MsiRecordGetFieldCount(hrec);
5865     ok(r == 2, "Expected 2, got %d\n", r);
5866
5867     r = MsiRecordGetInteger(hrec, 1);
5868     ok(r == 1, "Expected 1, got %d\n", r);
5869
5870     sz = sizeof(buffer);
5871     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5872     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5873     ok(!lstrcmpA(buffer, "one"), "Expected one, got '%s'\n", buffer);
5874
5875     r = MsiCloseHandle(hrec);
5876     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5877
5878     r = MsiViewFetch(hview, &hrec);
5879     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5880
5881     r = MsiViewClose(hview);
5882     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5883     r = MsiCloseHandle(hview);
5884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5885     r = MsiCloseHandle(hrec);
5886     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5887
5888     query = "SELECT * FROM `AAR`";
5889     r = MsiDatabaseOpenViewA(hdb, query, &hview);
5890     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5891
5892     r = MsiViewExecute(hview, 0);
5893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5894
5895     r = MsiViewFetch(hview, &hrec);
5896     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5897
5898     r = MsiRecordGetFieldCount(hrec);
5899     ok(r == 2, "Expected 2, got %d\n", r);
5900
5901     r = MsiRecordGetInteger(hrec, 1);
5902     ok(r == 2, "Expected 2, got %d\n", r);
5903
5904     sz = sizeof(buffer);
5905     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5906     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5907     ok(!lstrcmpA(buffer, "two"), "Expected two, got '%s'\n", buffer);
5908
5909     r = MsiCloseHandle(hrec);
5910     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5911
5912     r = MsiViewFetch(hview, &hrec);
5913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5914
5915     r = MsiRecordGetFieldCount(hrec);
5916     ok(r == 2, "Expected 2, got %d\n", r);
5917
5918     r = MsiRecordGetInteger(hrec, 1);
5919     ok(r == 5, "Expected 5, got %d\n", r);
5920
5921     sz = sizeof(buffer);
5922     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
5923     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5924     ok(!lstrcmpA(buffer, "five"), "Expected five, got '%s'\n", buffer);
5925
5926     r = MsiCloseHandle(hrec);
5927     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5928
5929     r = MsiViewFetch(hview, &hrec);
5930     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5931
5932     r = MsiViewClose(hview);
5933     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5934     r = MsiCloseHandle(hview);
5935     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5936     r = MsiCloseHandle(hrec);
5937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5938     r = MsiCloseHandle(hdb);
5939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5940
5941     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
5942     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
5943     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5944     ok(stg != NULL, "Expected non-NULL storage\n");
5945
5946     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5947     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5948     ok(stm != NULL, "Expected non-NULL stream\n");
5949
5950     hr = IStream_Read(stm, data, MAX_PATH, &read);
5951     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5952     ok(read == 4, "Expected 4, got %d\n", read);
5953     todo_wine ok(!memcmp(data, data10, read), "Unexpected data\n");
5954
5955     hr = IStream_Release(stm);
5956     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5957
5958     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5959     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5960     ok(stm != NULL, "Expected non-NULL stream\n");
5961
5962     hr = IStream_Read(stm, data, MAX_PATH, &read);
5963     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5964     ok(read == 8, "Expected 8, got %d\n", read);
5965     todo_wine
5966     {
5967         ok(!memcmp(data, data11, read), "Unexpected data\n");
5968     }
5969
5970     hr = IStream_Release(stm);
5971     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5972
5973     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5974     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5975     ok(stm != NULL, "Expected non-NULL stream\n");
5976
5977     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
5978     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5979     ok(read == 24, "Expected 24, got %d\n", read);
5980     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
5981
5982     hr = IStream_Release(stm);
5983     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5984
5985     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
5986     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5987     ok(stm != NULL, "Expected non-NULL stream\n");
5988
5989     hr = IStream_Read(stm, data, MAX_PATH, &read);
5990     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5991     todo_wine
5992     {
5993         ok(read == 64, "Expected 64, got %d\n", read);
5994         ok(!memcmp(data, data13, read), "Unexpected data\n");
5995     }
5996
5997     hr = IStream_Release(stm);
5998     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
5999
6000     hr = IStorage_Release(stg);
6001     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6002
6003     DeleteFileA(msifile);
6004 }
6005
6006 static void test_viewmodify_delete(void)
6007 {
6008     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
6009     UINT r;
6010     const char *query;
6011     char buffer[0x100];
6012     DWORD sz;
6013
6014     DeleteFileA(msifile);
6015
6016     /* just MsiOpenDatabase should not create a file */
6017     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6018     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6019
6020     query = "CREATE TABLE `phone` ( "
6021             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
6022             "PRIMARY KEY `id`)";
6023     r = run_query(hdb, 0, query);
6024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6025
6026     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6027         "VALUES('1', 'Alan', '5030581')";
6028     r = run_query(hdb, 0, query);
6029     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6030
6031     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6032         "VALUES('2', 'Barry', '928440')";
6033     r = run_query(hdb, 0, query);
6034     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6035
6036     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
6037         "VALUES('3', 'Cindy', '2937550')";
6038     r = run_query(hdb, 0, query);
6039     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6040
6041     query = "SELECT * FROM `phone` WHERE `id` <= 2";
6042     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6043     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6044     r = MsiViewExecute(hview, 0);
6045     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6046     r = MsiViewFetch(hview, &hrec);
6047     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6048
6049     /* delete 1 */
6050     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6051     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6052
6053     r = MsiCloseHandle(hrec);
6054     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6055     r = MsiViewFetch(hview, &hrec);
6056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6057
6058     /* delete 2 */
6059     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6061
6062     r = MsiCloseHandle(hrec);
6063     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6064     r = MsiViewClose(hview);
6065     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6066     r = MsiCloseHandle(hview);
6067     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6068
6069     query = "SELECT * FROM `phone`";
6070     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6071     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6072     r = MsiViewExecute(hview, 0);
6073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6074     r = MsiViewFetch(hview, &hrec);
6075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6076
6077     r = MsiRecordGetInteger(hrec, 1);
6078     ok(r == 3, "Expected 3, got %d\n", r);
6079
6080     sz = sizeof(buffer);
6081     r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
6082     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6083     ok(!lstrcmpA(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
6084
6085     sz = sizeof(buffer);
6086     r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
6087     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6088     ok(!lstrcmpA(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
6089
6090     r = MsiCloseHandle(hrec);
6091     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6092
6093     r = MsiViewFetch(hview, &hrec);
6094     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6095
6096     r = MsiViewClose(hview);
6097     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6098     r = MsiCloseHandle(hview);
6099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6100     r = MsiCloseHandle(hdb);
6101     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6102 }
6103
6104 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
6105 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
6106 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
6107
6108 static const WCHAR data14[] = { /* _StringPool */
6109 /*  len, refs */
6110     0,   0,    /* string 0 ''    */
6111 };
6112
6113 static const struct {
6114     LPCWSTR name;
6115     const void *data;
6116     DWORD size;
6117 } database_table_data[] =
6118 {
6119     {_Tables, NULL, 0},
6120     {_StringData, NULL, 0},
6121     {_StringPool, data14, sizeof data14},
6122 };
6123
6124 static void enum_stream_names(IStorage *stg)
6125 {
6126     IEnumSTATSTG *stgenum = NULL;
6127     IStream *stm;
6128     HRESULT hr;
6129     STATSTG stat;
6130     ULONG n, count;
6131     BYTE data[MAX_PATH];
6132     BYTE check[MAX_PATH];
6133     DWORD sz;
6134
6135     memset(check, 'a', MAX_PATH);
6136
6137     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
6138     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6139
6140     n = 0;
6141     while(TRUE)
6142     {
6143         count = 0;
6144         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
6145         if(FAILED(hr) || !count)
6146             break;
6147
6148         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
6149            "Expected table %d name to match\n", n);
6150
6151         stm = NULL;
6152         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
6153                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6154         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6155         ok(stm != NULL, "Expected non-NULL stream\n");
6156
6157         CoTaskMemFree(stat.pwcsName);
6158
6159         sz = MAX_PATH;
6160         memset(data, 'a', MAX_PATH);
6161         hr = IStream_Read(stm, data, sz, &count);
6162         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6163
6164         ok(count == database_table_data[n].size,
6165            "Expected %d, got %d\n", database_table_data[n].size, count);
6166
6167         if (!database_table_data[n].size)
6168             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
6169         else
6170             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
6171                "Expected table %d data to match\n", n);
6172
6173         IStream_Release(stm);
6174         n++;
6175     }
6176
6177     ok(n == 3, "Expected 3, got %d\n", n);
6178
6179     IEnumSTATSTG_Release(stgenum);
6180 }
6181
6182 static void test_defaultdatabase(void)
6183 {
6184     UINT r;
6185     HRESULT hr;
6186     MSIHANDLE hdb;
6187     IStorage *stg = NULL;
6188
6189     DeleteFileA(msifile);
6190
6191     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6192     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6193
6194     r = MsiDatabaseCommit(hdb);
6195     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6196
6197     MsiCloseHandle(hdb);
6198
6199     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
6200     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6201     ok(stg != NULL, "Expected non-NULL stg\n");
6202
6203     enum_stream_names(stg);
6204
6205     IStorage_Release(stg);
6206     DeleteFileA(msifile);
6207 }
6208
6209 static void test_order(void)
6210 {
6211     MSIHANDLE hdb, hview, hrec;
6212     CHAR buffer[MAX_PATH];
6213     LPCSTR query;
6214     UINT r, sz;
6215     int val;
6216
6217     hdb = create_db();
6218     ok(hdb, "failed to create db\n");
6219
6220     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
6221     r = run_query(hdb, 0, query);
6222     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6223
6224     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
6225     r = run_query(hdb, 0, query);
6226     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6227
6228     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
6229     r = run_query(hdb, 0, query);
6230     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6231
6232     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
6233     r = run_query(hdb, 0, query);
6234     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6235
6236     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
6237     r = run_query(hdb, 0, query);
6238     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6239
6240     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
6241     r = run_query(hdb, 0, query);
6242     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6243
6244     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
6245     r = run_query(hdb, 0, query);
6246     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6247
6248     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
6249     r = run_query(hdb, 0, query);
6250     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6251
6252     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
6253     r = run_query(hdb, 0, query);
6254     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6255
6256     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
6257     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6258     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6259     r = MsiViewExecute(hview, 0);
6260     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6261
6262     r = MsiViewFetch(hview, &hrec);
6263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6264
6265     val = MsiRecordGetInteger(hrec, 1);
6266     ok(val == 3, "Expected 3, got %d\n", val);
6267
6268     val = MsiRecordGetInteger(hrec, 2);
6269     ok(val == 4, "Expected 3, got %d\n", val);
6270
6271     MsiCloseHandle(hrec);
6272
6273     r = MsiViewFetch(hview, &hrec);
6274     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6275
6276     val = MsiRecordGetInteger(hrec, 1);
6277     ok(val == 5, "Expected 5, got %d\n", val);
6278
6279     val = MsiRecordGetInteger(hrec, 2);
6280     ok(val == 6, "Expected 6, got %d\n", val);
6281
6282     MsiCloseHandle(hrec);
6283
6284     r = MsiViewFetch(hview, &hrec);
6285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6286
6287     val = MsiRecordGetInteger(hrec, 1);
6288     ok(val == 1, "Expected 1, got %d\n", val);
6289
6290     val = MsiRecordGetInteger(hrec, 2);
6291     ok(val == 2, "Expected 2, got %d\n", val);
6292
6293     MsiCloseHandle(hrec);
6294
6295     r = MsiViewFetch(hview, &hrec);
6296     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6297
6298     MsiViewClose(hview);
6299     MsiCloseHandle(hview);
6300
6301     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
6302     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6303     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6304     r = MsiViewExecute(hview, 0);
6305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6306
6307     r = MsiViewFetch(hview, &hrec);
6308     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6309
6310     val = MsiRecordGetInteger(hrec, 1);
6311     ok(val == 1, "Expected 1, got %d\n", val);
6312
6313     val = MsiRecordGetInteger(hrec, 2);
6314     ok(val == 12, "Expected 12, got %d\n", val);
6315
6316     MsiCloseHandle(hrec);
6317
6318     r = MsiViewFetch(hview, &hrec);
6319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6320
6321     val = MsiRecordGetInteger(hrec, 1);
6322     ok(val == 3, "Expected 3, got %d\n", val);
6323
6324     val = MsiRecordGetInteger(hrec, 2);
6325     ok(val == 12, "Expected 12, got %d\n", val);
6326
6327     MsiCloseHandle(hrec);
6328
6329     r = MsiViewFetch(hview, &hrec);
6330     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6331
6332     val = MsiRecordGetInteger(hrec, 1);
6333     ok(val == 5, "Expected 5, got %d\n", val);
6334
6335     val = MsiRecordGetInteger(hrec, 2);
6336     ok(val == 12, "Expected 12, got %d\n", val);
6337
6338     MsiCloseHandle(hrec);
6339
6340     r = MsiViewFetch(hview, &hrec);
6341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6342
6343     val = MsiRecordGetInteger(hrec, 1);
6344     ok(val == 1, "Expected 1, got %d\n", val);
6345
6346     val = MsiRecordGetInteger(hrec, 2);
6347     ok(val == 14, "Expected 14, got %d\n", val);
6348
6349     MsiCloseHandle(hrec);
6350
6351     r = MsiViewFetch(hview, &hrec);
6352     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6353
6354     val = MsiRecordGetInteger(hrec, 1);
6355     ok(val == 3, "Expected 3, got %d\n", val);
6356
6357     val = MsiRecordGetInteger(hrec, 2);
6358     ok(val == 14, "Expected 14, got %d\n", val);
6359
6360     MsiCloseHandle(hrec);
6361
6362     r = MsiViewFetch(hview, &hrec);
6363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6364
6365     val = MsiRecordGetInteger(hrec, 1);
6366     ok(val == 5, "Expected 5, got %d\n", val);
6367
6368     val = MsiRecordGetInteger(hrec, 2);
6369     ok(val == 14, "Expected 14, got %d\n", val);
6370
6371     MsiCloseHandle(hrec);
6372
6373     r = MsiViewFetch(hview, &hrec);
6374     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6375
6376     val = MsiRecordGetInteger(hrec, 1);
6377     ok(val == 1, "Expected 1, got %d\n", val);
6378
6379     val = MsiRecordGetInteger(hrec, 2);
6380     ok(val == 10, "Expected 10, got %d\n", val);
6381
6382     MsiCloseHandle(hrec);
6383
6384     r = MsiViewFetch(hview, &hrec);
6385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6386
6387     val = MsiRecordGetInteger(hrec, 1);
6388     ok(val == 3, "Expected 3, got %d\n", val);
6389
6390     val = MsiRecordGetInteger(hrec, 2);
6391     ok(val == 10, "Expected 10, got %d\n", val);
6392
6393     MsiCloseHandle(hrec);
6394
6395     r = MsiViewFetch(hview, &hrec);
6396     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6397
6398     val = MsiRecordGetInteger(hrec, 1);
6399     ok(val == 5, "Expected 5, got %d\n", val);
6400
6401     val = MsiRecordGetInteger(hrec, 2);
6402     ok(val == 10, "Expected 10, got %d\n", val);
6403
6404     MsiCloseHandle(hrec);
6405
6406     r = MsiViewFetch(hview, &hrec);
6407     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6408
6409     MsiViewClose(hview);
6410     MsiCloseHandle(hview);
6411
6412     query = "SELECT * FROM `Empty` ORDER BY `A`";
6413     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6414     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6415     r = MsiViewExecute(hview, 0);
6416     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6417
6418     r = MsiViewFetch(hview, &hrec);
6419     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6420
6421     MsiViewClose(hview);
6422     MsiCloseHandle(hview);
6423
6424     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
6425     r = run_query(hdb, 0, query);
6426     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6427
6428     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno',  2)";
6429     r = run_query(hdb, 0, query);
6430     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6431
6432     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
6433     r = run_query(hdb, 0, query);
6434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6435
6436     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
6437     r = run_query(hdb, 0, query);
6438     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6439
6440     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
6441     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6442     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6443     r = MsiViewExecute(hview, 0);
6444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6445
6446     r = MsiViewFetch(hview, &hrec);
6447     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6448
6449     sz = sizeof(buffer);
6450     r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
6451     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6452     ok(!lstrcmpA(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
6453
6454     r = MsiRecordGetInteger(hrec, 2);
6455     ok(r == 3, "Expected 3, got %d\n", r);
6456
6457     MsiCloseHandle(hrec);
6458
6459     r = MsiViewFetch(hview, &hrec);
6460     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6461
6462     MsiViewClose(hview);
6463     MsiCloseHandle(hview);
6464     MsiCloseHandle(hdb);
6465 }
6466
6467 static void test_viewmodify_delete_temporary(void)
6468 {
6469     MSIHANDLE hdb, hview, hrec;
6470     const char *query;
6471     UINT r;
6472
6473     DeleteFileA(msifile);
6474
6475     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6476     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6477
6478     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
6479     r = run_query(hdb, 0, query);
6480     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6481
6482     query = "SELECT * FROM `Table`";
6483     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6484     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6485     r = MsiViewExecute(hview, 0);
6486     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6487
6488     hrec = MsiCreateRecord(1);
6489     MsiRecordSetInteger(hrec, 1, 1);
6490
6491     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6492     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6493
6494     MsiCloseHandle(hrec);
6495
6496     hrec = MsiCreateRecord(1);
6497     MsiRecordSetInteger(hrec, 1, 2);
6498
6499     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6500     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6501
6502     MsiCloseHandle(hrec);
6503
6504     hrec = MsiCreateRecord(1);
6505     MsiRecordSetInteger(hrec, 1, 3);
6506
6507     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
6508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6509
6510     MsiCloseHandle(hrec);
6511
6512     hrec = MsiCreateRecord(1);
6513     MsiRecordSetInteger(hrec, 1, 4);
6514
6515     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
6516     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6517
6518     MsiCloseHandle(hrec);
6519     MsiViewClose(hview);
6520     MsiCloseHandle(hview);
6521
6522     query = "SELECT * FROM `Table` WHERE  `A` = 2";
6523     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6524     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6525     r = MsiViewExecute(hview, 0);
6526     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6527     r = MsiViewFetch(hview, &hrec);
6528     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6529
6530     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6531     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6532
6533     MsiCloseHandle(hrec);
6534     MsiViewClose(hview);
6535     MsiCloseHandle(hview);
6536
6537     query = "SELECT * FROM `Table` WHERE  `A` = 3";
6538     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6539     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6540     r = MsiViewExecute(hview, 0);
6541     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6542     r = MsiViewFetch(hview, &hrec);
6543     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6544
6545     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
6546     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6547
6548     MsiCloseHandle(hrec);
6549     MsiViewClose(hview);
6550     MsiCloseHandle(hview);
6551
6552     query = "SELECT * FROM `Table` ORDER BY `A`";
6553     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6554     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6555     r = MsiViewExecute(hview, 0);
6556     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6557
6558     r = MsiViewFetch(hview, &hrec);
6559     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6560
6561     r = MsiRecordGetInteger(hrec, 1);
6562     ok(r == 1, "Expected 1, got %d\n", r);
6563
6564     MsiCloseHandle(hrec);
6565
6566     r = MsiViewFetch(hview, &hrec);
6567     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6568
6569     r = MsiRecordGetInteger(hrec, 1);
6570     ok(r == 4, "Expected 4, got %d\n", r);
6571
6572     MsiCloseHandle(hrec);
6573
6574     r = MsiViewFetch(hview, &hrec);
6575     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6576
6577     MsiViewClose(hview);
6578     MsiCloseHandle(hview);
6579     MsiCloseHandle(hdb);
6580     DeleteFileA(msifile);
6581 }
6582
6583 static void test_deleterow(void)
6584 {
6585     MSIHANDLE hdb, hview, hrec;
6586     const char *query;
6587     char buf[MAX_PATH];
6588     UINT r;
6589     DWORD size;
6590
6591     DeleteFileA(msifile);
6592
6593     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6595
6596     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6597     r = run_query(hdb, 0, query);
6598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6599
6600     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
6601     r = run_query(hdb, 0, query);
6602     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6603
6604     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
6605     r = run_query(hdb, 0, query);
6606     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6607
6608     query = "DELETE FROM `Table` WHERE `A` = 'one'";
6609     r = run_query(hdb, 0, query);
6610     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6611
6612     r = MsiDatabaseCommit(hdb);
6613     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6614
6615     MsiCloseHandle(hdb);
6616
6617     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
6618     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6619
6620     query = "SELECT * FROM `Table`";
6621     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6623     r = MsiViewExecute(hview, 0);
6624     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6625
6626     r = MsiViewFetch(hview, &hrec);
6627     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6628
6629     size = MAX_PATH;
6630     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6631     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6632     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
6633
6634     MsiCloseHandle(hrec);
6635
6636     r = MsiViewFetch(hview, &hrec);
6637     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6638
6639     MsiViewClose(hview);
6640     MsiCloseHandle(hview);
6641     MsiCloseHandle(hdb);
6642     DeleteFileA(msifile);
6643 }
6644
6645 static const CHAR import_dat[] = "A\n"
6646                                  "s72\n"
6647                                  "Table\tA\n"
6648                                  "This is a new 'string' ok\n";
6649
6650 static void test_quotes(void)
6651 {
6652     MSIHANDLE hdb, hview, hrec;
6653     const char *query;
6654     char buf[MAX_PATH];
6655     UINT r;
6656     DWORD size;
6657
6658     DeleteFileA(msifile);
6659
6660     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6662
6663     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6664     r = run_query(hdb, 0, query);
6665     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6666
6667     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
6668     r = run_query(hdb, 0, query);
6669     ok(r == ERROR_BAD_QUERY_SYNTAX,
6670        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6671
6672     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
6673     r = run_query(hdb, 0, query);
6674     ok(r == ERROR_BAD_QUERY_SYNTAX,
6675        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6676
6677     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
6678     r = run_query(hdb, 0, query);
6679     ok(r == ERROR_BAD_QUERY_SYNTAX,
6680        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6681
6682     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
6683     r = run_query(hdb, 0, query);
6684     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6685
6686     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
6687     r = run_query(hdb, 0, query);
6688     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6689
6690     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
6691     r = run_query(hdb, 0, query);
6692     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6693
6694     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
6695     r = run_query(hdb, 0, query);
6696     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6697
6698     query = "SELECT * FROM `Table`";
6699     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6700     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6701
6702     r = MsiViewExecute(hview, 0);
6703     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6704
6705     r = MsiViewFetch(hview, &hrec);
6706     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6707
6708     size = MAX_PATH;
6709     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6710     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6711     ok(!lstrcmpA(buf, "This is a \"string\" ok"),
6712        "Expected \"This is a \"string\" ok\", got %s\n", buf);
6713
6714     MsiCloseHandle(hrec);
6715
6716     r = MsiViewFetch(hview, &hrec);
6717     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6718
6719     MsiViewClose(hview);
6720     MsiCloseHandle(hview);
6721
6722     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
6723
6724     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
6725     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6726
6727     DeleteFileA("import.idt");
6728
6729     query = "SELECT * FROM `Table`";
6730     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6732
6733     r = MsiViewExecute(hview, 0);
6734     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6735
6736     r = MsiViewFetch(hview, &hrec);
6737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6738
6739     size = MAX_PATH;
6740     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6742     ok(!lstrcmpA(buf, "This is a new 'string' ok"),
6743        "Expected \"This is a new 'string' ok\", got %s\n", buf);
6744
6745     MsiCloseHandle(hrec);
6746
6747     r = MsiViewFetch(hview, &hrec);
6748     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6749
6750     MsiViewClose(hview);
6751     MsiCloseHandle(hview);
6752     MsiCloseHandle(hdb);
6753     DeleteFileA(msifile);
6754 }
6755
6756 static void test_carriagereturn(void)
6757 {
6758     MSIHANDLE hdb, hview, hrec;
6759     const char *query;
6760     char buf[MAX_PATH];
6761     UINT r;
6762     DWORD size;
6763
6764     DeleteFileA(msifile);
6765
6766     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6768
6769     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6770     r = run_query(hdb, 0, query);
6771     ok(r == ERROR_BAD_QUERY_SYNTAX,
6772        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6773
6774     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6775     r = run_query(hdb, 0, query);
6776     ok(r == ERROR_BAD_QUERY_SYNTAX,
6777        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6778
6779     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6780     r = run_query(hdb, 0, query);
6781     ok(r == ERROR_BAD_QUERY_SYNTAX,
6782        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6783
6784     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6785     r = run_query(hdb, 0, query);
6786     ok(r == ERROR_BAD_QUERY_SYNTAX,
6787        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6788
6789     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6790     r = run_query(hdb, 0, query);
6791     ok(r == ERROR_BAD_QUERY_SYNTAX,
6792        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6793
6794     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
6795     r = run_query(hdb, 0, query);
6796     ok(r == ERROR_BAD_QUERY_SYNTAX,
6797        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6798
6799     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
6800     r = run_query(hdb, 0, query);
6801     ok(r == ERROR_BAD_QUERY_SYNTAX,
6802        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6803
6804     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
6805     r = run_query(hdb, 0, query);
6806     ok(r == ERROR_BAD_QUERY_SYNTAX,
6807        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6808
6809     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
6810     r = run_query(hdb, 0, query);
6811     ok(r == ERROR_BAD_QUERY_SYNTAX,
6812        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6813
6814     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
6815     r = run_query(hdb, 0, query);
6816     ok(r == ERROR_BAD_QUERY_SYNTAX,
6817        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6818
6819     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
6820     r = run_query(hdb, 0, query);
6821     ok(r == ERROR_BAD_QUERY_SYNTAX,
6822        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6823
6824     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
6825     r = run_query(hdb, 0, query);
6826     ok(r == ERROR_BAD_QUERY_SYNTAX,
6827        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6828
6829     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
6830     r = run_query(hdb, 0, query);
6831     ok(r == ERROR_BAD_QUERY_SYNTAX,
6832        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6833
6834     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
6835     r = run_query(hdb, 0, query);
6836     ok(r == ERROR_BAD_QUERY_SYNTAX,
6837        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6838
6839     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
6840     r = run_query(hdb, 0, query);
6841     ok(r == ERROR_BAD_QUERY_SYNTAX,
6842        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6843
6844     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
6845     r = run_query(hdb, 0, query);
6846     ok(r == ERROR_BAD_QUERY_SYNTAX,
6847        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6848
6849     query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6850     r = run_query(hdb, 0, query);
6851     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6852
6853     query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6854     r = run_query(hdb, 0, query);
6855     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6856
6857     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6858     r = run_query(hdb, 0, query);
6859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6860
6861     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6862     r = run_query(hdb, 0, query);
6863     ok(r == ERROR_BAD_QUERY_SYNTAX,
6864        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6865
6866     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6867     r = run_query(hdb, 0, query);
6868     ok(r == ERROR_BAD_QUERY_SYNTAX,
6869        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6870
6871     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
6872     r = run_query(hdb, 0, query);
6873     ok(r == ERROR_BAD_QUERY_SYNTAX,
6874        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6875
6876     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
6877     r = run_query(hdb, 0, query);
6878     ok(r == ERROR_BAD_QUERY_SYNTAX,
6879        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6880
6881     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
6882     r = run_query(hdb, 0, query);
6883     ok(r == ERROR_BAD_QUERY_SYNTAX,
6884        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6885
6886     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6887     r = run_query(hdb, 0, query);
6888     ok(r == ERROR_BAD_QUERY_SYNTAX,
6889        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6890
6891     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
6892     r = run_query(hdb, 0, query);
6893     ok(r == ERROR_BAD_QUERY_SYNTAX,
6894        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6895
6896     query = "SELECT * FROM `_Tables`";
6897     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6898     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6899     r = MsiViewExecute(hview, 0);
6900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6901
6902     r = MsiViewFetch(hview, &hrec);
6903     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6904
6905     size = MAX_PATH;
6906     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6908     ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
6909
6910     MsiCloseHandle(hrec);
6911
6912     r = MsiViewFetch(hview, &hrec);
6913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6914
6915     size = MAX_PATH;
6916     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6918     ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
6919
6920     MsiCloseHandle(hrec);
6921
6922     r = MsiViewFetch(hview, &hrec);
6923     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6924
6925     size = MAX_PATH;
6926     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6927     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6928     ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
6929
6930     MsiCloseHandle(hrec);
6931
6932     r = MsiViewFetch(hview, &hrec);
6933     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6934
6935     MsiViewClose(hview);
6936     MsiCloseHandle(hview);
6937
6938     MsiCloseHandle(hdb);
6939     DeleteFileA(msifile);
6940 }
6941
6942 static void test_noquotes(void)
6943 {
6944     MSIHANDLE hdb, hview, hrec;
6945     const char *query;
6946     char buf[MAX_PATH];
6947     UINT r;
6948     DWORD size;
6949
6950     DeleteFileA(msifile);
6951
6952     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
6953     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6954
6955     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
6956     r = run_query(hdb, 0, query);
6957     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
6958
6959     query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
6960     r = run_query(hdb, 0, query);
6961     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6962
6963     query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL 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 `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
6968     r = run_query(hdb, 0, query);
6969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6970
6971     query = "SELECT * FROM `_Tables`";
6972     r = MsiDatabaseOpenViewA(hdb, query, &hview);
6973     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6974     r = MsiViewExecute(hview, 0);
6975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6976
6977     r = MsiViewFetch(hview, &hrec);
6978     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6979
6980     size = MAX_PATH;
6981     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6982     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6983     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
6984
6985     MsiCloseHandle(hrec);
6986
6987     r = MsiViewFetch(hview, &hrec);
6988     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6989
6990     size = MAX_PATH;
6991     r = MsiRecordGetStringA(hrec, 1, buf, &size);
6992     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6993     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
6994
6995     MsiCloseHandle(hrec);
6996
6997     r = MsiViewFetch(hview, &hrec);
6998     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
6999
7000     size = MAX_PATH;
7001     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7002     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7003     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7004
7005     MsiCloseHandle(hrec);
7006
7007     r = MsiViewFetch(hview, &hrec);
7008     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7009
7010     MsiViewClose(hview);
7011     MsiCloseHandle(hview);
7012
7013     query = "SELECT * FROM `_Columns`";
7014     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7015     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7016     r = MsiViewExecute(hview, 0);
7017     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7018
7019     r = MsiViewFetch(hview, &hrec);
7020     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7021
7022     size = MAX_PATH;
7023     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7025     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
7026
7027     r = MsiRecordGetInteger(hrec, 2);
7028     ok(r == 1, "Expected 1, got %d\n", r);
7029
7030     size = MAX_PATH;
7031     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7032     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7033     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7034
7035     MsiCloseHandle(hrec);
7036
7037     r = MsiViewFetch(hview, &hrec);
7038     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7039
7040     size = MAX_PATH;
7041     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7042     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7043     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
7044
7045     r = MsiRecordGetInteger(hrec, 2);
7046     ok(r == 1, "Expected 1, got %d\n", r);
7047
7048     size = MAX_PATH;
7049     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7051     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7052
7053     MsiCloseHandle(hrec);
7054
7055     r = MsiViewFetch(hview, &hrec);
7056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7057
7058     size = MAX_PATH;
7059     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7061     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
7062
7063     r = MsiRecordGetInteger(hrec, 2);
7064     ok(r == 1, "Expected 1, got %d\n", r);
7065
7066     size = MAX_PATH;
7067     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7068     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7069     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7070
7071     MsiCloseHandle(hrec);
7072
7073     r = MsiViewFetch(hview, &hrec);
7074     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7075
7076     MsiViewClose(hview);
7077     MsiCloseHandle(hview);
7078
7079     query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
7080     r = run_query(hdb, 0, query);
7081     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7082
7083     query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
7084     r = run_query(hdb, 0, query);
7085     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7086
7087     query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
7088     r = run_query(hdb, 0, query);
7089     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7090
7091     query = "SELECT * FROM Table WHERE `A` = 'hi'";
7092     r = run_query(hdb, 0, query);
7093     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7094
7095     query = "SELECT * FROM `Table` WHERE `A` = hi";
7096     r = run_query(hdb, 0, query);
7097     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7098
7099     query = "SELECT * FROM Table";
7100     r = run_query(hdb, 0, query);
7101     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7102
7103     query = "SELECT * FROM Table2";
7104     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7106     r = MsiViewExecute(hview, 0);
7107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7108
7109     r = MsiViewFetch(hview, &hrec);
7110     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7111
7112     MsiViewClose(hview);
7113     MsiCloseHandle(hview);
7114
7115     query = "SELECT * FROM `Table` WHERE A = 'hi'";
7116     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7117     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7118     r = MsiViewExecute(hview, 0);
7119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7120
7121     r = MsiViewFetch(hview, &hrec);
7122     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7123
7124     size = MAX_PATH;
7125     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7126     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7127     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
7128
7129     MsiCloseHandle(hrec);
7130
7131     r = MsiViewFetch(hview, &hrec);
7132     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7133
7134     MsiViewClose(hview);
7135     MsiCloseHandle(hview);
7136     MsiCloseHandle(hdb);
7137     DeleteFileA(msifile);
7138 }
7139
7140 static void read_file_data(LPCSTR filename, LPSTR buffer)
7141 {
7142     HANDLE file;
7143     DWORD read;
7144
7145     file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
7146     ZeroMemory(buffer, MAX_PATH);
7147     ReadFile(file, buffer, MAX_PATH, &read, NULL);
7148     CloseHandle(file);
7149 }
7150
7151 static void test_forcecodepage(void)
7152 {
7153     MSIHANDLE hdb;
7154     const char *query;
7155     char buffer[MAX_PATH];
7156     UINT r;
7157
7158     DeleteFileA(msifile);
7159     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
7160
7161     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7162     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7163
7164     query = "SELECT * FROM `_ForceCodepage`";
7165     r = run_query(hdb, 0, query);
7166     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7167
7168     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
7169     r = run_query(hdb, 0, query);
7170     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7171
7172     query = "SELECT * FROM `_ForceCodepage`";
7173     r = run_query(hdb, 0, query);
7174     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7175
7176     r = MsiDatabaseCommit(hdb);
7177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7178
7179     query = "SELECT * FROM `_ForceCodepage`";
7180     r = run_query(hdb, 0, query);
7181     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7182
7183     MsiCloseHandle(hdb);
7184
7185     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb);
7186     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7187
7188     query = "SELECT * FROM `_ForceCodepage`";
7189     r = run_query(hdb, 0, query);
7190     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7191
7192     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7193     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7194
7195     read_file_data("forcecodepage.idt", buffer);
7196     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
7197        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7198
7199     create_file_data("forcecodepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
7200
7201     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7202     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7203
7204     r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
7205     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7206
7207     read_file_data("forcecodepage.idt", buffer);
7208     ok(!lstrcmpA(buffer, "\r\n\r\n850\t_ForceCodepage\r\n"),
7209        "Expected \"\r\n\r\n850\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
7210
7211     create_file_data("forcecodepage.idt", "\r\n\r\n9999\t_ForceCodepage\r\n", 0);
7212
7213     r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
7214     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_SUCCESS, got %d\n", r);
7215
7216     MsiCloseHandle(hdb);
7217     DeleteFileA(msifile);
7218     DeleteFileA("forcecodepage.idt");
7219 }
7220
7221 static void test_viewmodify_refresh(void)
7222 {
7223     MSIHANDLE hdb, hview, hrec;
7224     const char *query;
7225     char buffer[MAX_PATH];
7226     UINT r;
7227     DWORD size;
7228
7229     DeleteFileA(msifile);
7230
7231     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7232     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7233
7234     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
7235     r = run_query(hdb, 0, query);
7236     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7237
7238     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
7239     r = run_query(hdb, 0, query);
7240     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7241
7242     query = "SELECT * FROM `Table`";
7243     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7244     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7245     r = MsiViewExecute(hview, 0);
7246     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7247
7248     r = MsiViewFetch(hview, &hrec);
7249     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7250
7251     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
7252     r = run_query(hdb, 0, query);
7253     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7254
7255     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7257
7258     size = MAX_PATH;
7259     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7260     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7261     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
7262     ok(size == 2, "Expected 2, got %d\n", size);
7263
7264     r = MsiRecordGetInteger(hrec, 2);
7265     ok(r == 2, "Expected 2, got %d\n", r);
7266
7267     MsiCloseHandle(hrec);
7268     MsiViewClose(hview);
7269     MsiCloseHandle(hview);
7270
7271     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
7272     r = run_query(hdb, 0, query);
7273     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7274
7275     query = "SELECT * FROM `Table` WHERE `B` = 3";
7276     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7277     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7278     r = MsiViewExecute(hview, 0);
7279     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7280
7281     r = MsiViewFetch(hview, &hrec);
7282     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7283
7284     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
7285     r = run_query(hdb, 0, query);
7286     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7287
7288     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
7289     r = run_query(hdb, 0, query);
7290     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7291
7292     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7294
7295     size = MAX_PATH;
7296     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
7297     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7298     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
7299     ok(size == 5, "Expected 5, got %d\n", size);
7300
7301     r = MsiRecordGetInteger(hrec, 2);
7302     ok(r == 2, "Expected 2, got %d\n", r);
7303
7304     MsiCloseHandle(hrec);
7305     MsiViewClose(hview);
7306     MsiCloseHandle(hview);
7307     MsiCloseHandle(hdb);
7308     DeleteFileA(msifile);
7309 }
7310
7311 static void test_where_viewmodify(void)
7312 {
7313     MSIHANDLE hdb, hview, hrec;
7314     const char *query;
7315     UINT r;
7316
7317     DeleteFileA(msifile);
7318
7319     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7320     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7321
7322     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
7323     r = run_query(hdb, 0, query);
7324     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7325
7326     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
7327     r = run_query(hdb, 0, query);
7328     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7329
7330     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
7331     r = run_query(hdb, 0, query);
7332     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7333
7334     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
7335     r = run_query(hdb, 0, query);
7336     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7337
7338     /* `B` = 3 doesn't match, but the view shouldn't be executed */
7339     query = "SELECT * FROM `Table` WHERE `B` = 3";
7340     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7341     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7342
7343     hrec = MsiCreateRecord(2);
7344     MsiRecordSetInteger(hrec, 1, 7);
7345     MsiRecordSetInteger(hrec, 2, 8);
7346
7347     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
7348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7349
7350     MsiCloseHandle(hrec);
7351     MsiViewClose(hview);
7352     MsiCloseHandle(hview);
7353
7354     query = "SELECT * FROM `Table` WHERE `A` = 7";
7355     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7356     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7357     r = MsiViewExecute(hview, 0);
7358     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7359
7360     r = MsiViewFetch(hview, &hrec);
7361     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7362
7363     r = MsiRecordGetInteger(hrec, 1);
7364     ok(r == 7, "Expected 7, got %d\n", r);
7365
7366     r = MsiRecordGetInteger(hrec, 2);
7367     ok(r == 8, "Expected 8, got %d\n", r);
7368
7369     MsiRecordSetInteger(hrec, 2, 9);
7370
7371     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
7372     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7373
7374     MsiCloseHandle(hrec);
7375     MsiViewClose(hview);
7376     MsiCloseHandle(hview);
7377
7378     query = "SELECT * FROM `Table` WHERE `A` = 7";
7379     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7380     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7381     r = MsiViewExecute(hview, 0);
7382     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7383
7384     r = MsiViewFetch(hview, &hrec);
7385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7386
7387     r = MsiRecordGetInteger(hrec, 1);
7388     ok(r == 7, "Expected 7, got %d\n", r);
7389
7390     r = MsiRecordGetInteger(hrec, 2);
7391     ok(r == 9, "Expected 9, got %d\n", r);
7392
7393     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
7394     r = run_query(hdb, 0, query);
7395     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7396
7397     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
7398     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7399
7400     r = MsiRecordGetInteger(hrec, 1);
7401     ok(r == 7, "Expected 7, got %d\n", r);
7402
7403     r = MsiRecordGetInteger(hrec, 2);
7404     ok(r == 10, "Expected 10, got %d\n", r);
7405
7406     MsiCloseHandle(hrec);
7407     MsiViewClose(hview);
7408     MsiCloseHandle(hview);
7409     MsiCloseHandle(hdb);
7410 }
7411
7412 static BOOL create_storage(LPCSTR name)
7413 {
7414     WCHAR nameW[MAX_PATH];
7415     IStorage *stg;
7416     IStream *stm;
7417     HRESULT hr;
7418     DWORD count;
7419     BOOL res = FALSE;
7420
7421     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
7422     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
7423                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
7424     if (FAILED(hr))
7425         return FALSE;
7426
7427     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
7428                                0, 0, &stm);
7429     if (FAILED(hr))
7430         goto done;
7431
7432     hr = IStream_Write(stm, "stgdata", 8, &count);
7433     if (SUCCEEDED(hr))
7434         res = TRUE;
7435
7436 done:
7437     IStream_Release(stm);
7438     IStorage_Release(stg);
7439
7440     return res;
7441 }
7442
7443 static void test_storages_table(void)
7444 {
7445     MSIHANDLE hdb, hview, hrec;
7446     IStorage *stg, *inner;
7447     IStream *stm;
7448     char file[MAX_PATH];
7449     char buf[MAX_PATH];
7450     WCHAR name[MAX_PATH];
7451     LPCSTR query;
7452     HRESULT hr;
7453     DWORD size;
7454     UINT r;
7455
7456     hdb = create_db();
7457     ok(hdb, "failed to create db\n");
7458
7459     r = MsiDatabaseCommit(hdb);
7460     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
7461
7462     MsiCloseHandle(hdb);
7463
7464     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb);
7465     ok(r == ERROR_SUCCESS , "Failed to open database\n");
7466
7467     /* check the column types */
7468     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
7469     ok(hrec, "failed to get column info hrecord\n");
7470     ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
7471     ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
7472
7473     MsiCloseHandle(hrec);
7474
7475     /* now try the names */
7476     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
7477     ok(hrec, "failed to get column info hrecord\n");
7478     ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
7479     ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
7480
7481     MsiCloseHandle(hrec);
7482
7483     create_storage("storage.bin");
7484
7485     hrec = MsiCreateRecord(2);
7486     MsiRecordSetStringA(hrec, 1, "stgname");
7487
7488     r = MsiRecordSetStreamA(hrec, 2, "storage.bin");
7489     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
7490
7491     DeleteFileA("storage.bin");
7492
7493     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
7494     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7495     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7496
7497     r = MsiViewExecute(hview, hrec);
7498     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7499
7500     MsiCloseHandle(hrec);
7501     MsiViewClose(hview);
7502     MsiCloseHandle(hview);
7503
7504     query = "SELECT `Name`, `Data` FROM `_Storages`";
7505     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7506     ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
7507
7508     r = MsiViewExecute(hview, 0);
7509     ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
7510
7511     r = MsiViewFetch(hview, &hrec);
7512     ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
7513
7514     size = MAX_PATH;
7515     r = MsiRecordGetStringA(hrec, 1, file, &size);
7516     ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
7517     ok(!lstrcmpA(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
7518
7519     size = MAX_PATH;
7520     lstrcpyA(buf, "apple");
7521     r = MsiRecordReadStream(hrec, 2, buf, &size);
7522     ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
7523     ok(!lstrcmpA(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
7524     ok(size == 0, "Expected 0, got %d\n", size);
7525
7526     MsiCloseHandle(hrec);
7527
7528     r = MsiViewFetch(hview, &hrec);
7529     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7530
7531     MsiViewClose(hview);
7532     MsiCloseHandle(hview);
7533
7534     MsiDatabaseCommit(hdb);
7535     MsiCloseHandle(hdb);
7536
7537     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
7538     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
7539                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
7540     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7541     ok(stg != NULL, "Expected non-NULL storage\n");
7542
7543     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
7544     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
7545                               NULL, 0, &inner);
7546     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7547     ok(inner != NULL, "Expected non-NULL storage\n");
7548
7549     MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
7550     hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
7551     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
7552     ok(stm != NULL, "Expected non-NULL stream\n");
7553
7554     hr = IStream_Read(stm, buf, MAX_PATH, &size);
7555     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
7556     ok(size == 8, "Expected 8, got %d\n", size);
7557     ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
7558
7559     IStream_Release(stm);
7560     IStorage_Release(inner);
7561
7562     IStorage_Release(stg);
7563     DeleteFileA(msifile);
7564 }
7565
7566 static void test_dbtopackage(void)
7567 {
7568     MSIHANDLE hdb, hpkg;
7569     CHAR package[12], buf[MAX_PATH];
7570     DWORD size;
7571     UINT r;
7572
7573     /* create an empty database, transact mode */
7574     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7575     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7576
7577     set_summary_info(hdb);
7578
7579     r = create_directory_table(hdb);
7580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7581
7582     r = create_custom_action_table(hdb);
7583     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7584
7585     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7586     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7587
7588     sprintf(package, "#%u", hdb);
7589     r = MsiOpenPackageA(package, &hpkg);
7590     if (r == ERROR_INSTALL_PACKAGE_REJECTED)
7591     {
7592         skip("Not enough rights to perform tests\n");
7593         goto error;
7594     }
7595     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7596
7597     /* property is not set yet */
7598     size = MAX_PATH;
7599     lstrcpyA(buf, "kiwi");
7600     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7601     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7602     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7603     ok(size == 0, "Expected 0, got %d\n", size);
7604
7605     /* run the custom action to set the property */
7606     r = MsiDoActionA(hpkg, "SetProp");
7607     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7608
7609     /* property is now set */
7610     size = MAX_PATH;
7611     lstrcpyA(buf, "kiwi");
7612     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7613     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7614     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7615     ok(size == 5, "Expected 5, got %d\n", size);
7616
7617     MsiCloseHandle(hpkg);
7618
7619     /* reset the package */
7620     r = MsiOpenPackageA(package, &hpkg);
7621     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7622
7623     /* property is not set anymore */
7624     size = MAX_PATH;
7625     lstrcpyA(buf, "kiwi");
7626     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7627     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7628     todo_wine
7629     {
7630         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7631         ok(size == 0, "Expected 0, got %d\n", size);
7632     }
7633
7634     MsiCloseHandle(hdb);
7635     MsiCloseHandle(hpkg);
7636
7637     /* create an empty database, direct mode */
7638     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
7639     ok(r == ERROR_SUCCESS, "Failed to create database\n");
7640
7641     set_summary_info(hdb);
7642
7643     r = create_directory_table(hdb);
7644     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7645
7646     r = create_custom_action_table(hdb);
7647     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7648
7649     r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
7650     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7651
7652     sprintf(package, "#%u", hdb);
7653     r = MsiOpenPackageA(package, &hpkg);
7654     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7655
7656     /* property is not set yet */
7657     size = MAX_PATH;
7658     lstrcpyA(buf, "kiwi");
7659     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7660     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7661     ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7662     ok(size == 0, "Expected 0, got %d\n", size);
7663
7664     /* run the custom action to set the property */
7665     r = MsiDoActionA(hpkg, "SetProp");
7666     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7667
7668     /* property is now set */
7669     size = MAX_PATH;
7670     lstrcpyA(buf, "kiwi");
7671     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7672     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7673     ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
7674     ok(size == 5, "Expected 5, got %d\n", size);
7675
7676     MsiCloseHandle(hpkg);
7677
7678     /* reset the package */
7679     r = MsiOpenPackageA(package, &hpkg);
7680     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7681
7682     /* property is not set anymore */
7683     size = MAX_PATH;
7684     lstrcpyA(buf, "kiwi");
7685     r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
7686     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7687     todo_wine
7688     {
7689         ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
7690         ok(size == 0, "Expected 0, got %d\n", size);
7691     }
7692
7693     MsiCloseHandle(hpkg);
7694
7695 error:
7696     MsiCloseHandle(hdb);
7697     DeleteFileA(msifile);
7698 }
7699
7700 static void test_droptable(void)
7701 {
7702     MSIHANDLE hdb, hview, hrec;
7703     CHAR buf[MAX_PATH];
7704     LPCSTR query;
7705     DWORD size;
7706     UINT r;
7707
7708     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7710
7711     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7712     r = run_query(hdb, 0, query);
7713     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7714
7715     query = "SELECT * FROM `One`";
7716     r = do_query(hdb, query, &hrec);
7717     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7718
7719     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7720     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7721     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7722     r = MsiViewExecute(hview, 0);
7723     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7724
7725     r = MsiViewFetch(hview, &hrec);
7726     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7727
7728     size = MAX_PATH;
7729     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7730     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7731     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7732
7733     MsiCloseHandle(hrec);
7734     MsiViewClose(hview);
7735     MsiCloseHandle(hview);
7736
7737     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7738     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7739     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7740     r = MsiViewExecute(hview, 0);
7741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7742
7743     r = MsiViewFetch(hview, &hrec);
7744     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7745
7746     size = MAX_PATH;
7747     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7748     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7749     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7750
7751     r = MsiRecordGetInteger(hrec, 2);
7752     ok(r == 1, "Expected 1, got %d\n", r);
7753
7754     size = MAX_PATH;
7755     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7756     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7757     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
7758
7759     MsiCloseHandle(hrec);
7760
7761     r = MsiViewFetch(hview, &hrec);
7762     ok(r == ERROR_NO_MORE_ITEMS,
7763        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7764
7765     MsiViewClose(hview);
7766     MsiCloseHandle(hview);
7767
7768     query = "DROP `One`";
7769     r = run_query(hdb, 0, query);
7770     ok(r == ERROR_BAD_QUERY_SYNTAX,
7771        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7772
7773     query = "DROP TABLE";
7774     r = run_query(hdb, 0, query);
7775     ok(r == ERROR_BAD_QUERY_SYNTAX,
7776        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7777
7778     query = "DROP TABLE `One`";
7779     hview = 0;
7780     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7781     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7782     r = MsiViewExecute(hview, 0);
7783     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7784
7785     r = MsiViewFetch(hview, &hrec);
7786     ok(r == ERROR_FUNCTION_FAILED,
7787        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
7788
7789     MsiViewClose(hview);
7790     MsiCloseHandle(hview);
7791
7792     query = "SELECT * FROM `IDontExist`";
7793     r = do_query(hdb, query, &hrec);
7794     ok(r == ERROR_BAD_QUERY_SYNTAX,
7795        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7796
7797     query = "SELECT * FROM `One`";
7798     r = do_query(hdb, query, &hrec);
7799     ok(r == ERROR_BAD_QUERY_SYNTAX,
7800        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7801
7802     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7803     r = run_query(hdb, 0, query);
7804     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7805
7806     query = "DROP TABLE One";
7807     r = run_query(hdb, 0, query);
7808     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7809
7810     query = "SELECT * FROM `One`";
7811     r = do_query(hdb, query, &hrec);
7812     ok(r == ERROR_BAD_QUERY_SYNTAX,
7813        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7814
7815     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7816     r = do_query(hdb, query, &hrec);
7817     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7818
7819     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7820     r = do_query(hdb, query, &hrec);
7821     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7822
7823     query = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
7824     r = run_query(hdb, 0, query);
7825     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7826
7827     query = "SELECT * FROM `One`";
7828     r = do_query(hdb, query, &hrec);
7829     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7830
7831     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7832     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7833     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7834     r = MsiViewExecute(hview, 0);
7835     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7836
7837     r = MsiViewFetch(hview, &hrec);
7838     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7839
7840     size = MAX_PATH;
7841     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7842     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7843     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7844
7845     MsiCloseHandle(hrec);
7846     MsiViewClose(hview);
7847     MsiCloseHandle(hview);
7848
7849     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7850     r = MsiDatabaseOpenViewA(hdb, query, &hview);
7851     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7852     r = MsiViewExecute(hview, 0);
7853     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7854
7855     r = MsiViewFetch(hview, &hrec);
7856     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7857
7858     size = MAX_PATH;
7859     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7861     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7862
7863     r = MsiRecordGetInteger(hrec, 2);
7864     ok(r == 1, "Expected 1, got %d\n", r);
7865
7866     size = MAX_PATH;
7867     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7868     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7869     ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
7870
7871     MsiCloseHandle(hrec);
7872
7873     r = MsiViewFetch(hview, &hrec);
7874     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7875
7876     size = MAX_PATH;
7877     r = MsiRecordGetStringA(hrec, 1, buf, &size);
7878     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7879     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
7880
7881     r = MsiRecordGetInteger(hrec, 2);
7882     ok(r == 2, "Expected 2, got %d\n", r);
7883
7884     size = MAX_PATH;
7885     r = MsiRecordGetStringA(hrec, 3, buf, &size);
7886     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7887     ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
7888
7889     MsiCloseHandle(hrec);
7890
7891     r = MsiViewFetch(hview, &hrec);
7892     ok(r == ERROR_NO_MORE_ITEMS,
7893        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7894
7895     MsiViewClose(hview);
7896     MsiCloseHandle(hview);
7897
7898     query = "DROP TABLE One";
7899     r = run_query(hdb, 0, query);
7900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7901
7902     query = "SELECT * FROM `One`";
7903     r = do_query(hdb, query, &hrec);
7904     ok(r == ERROR_BAD_QUERY_SYNTAX,
7905        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7906
7907     query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
7908     r = do_query(hdb, query, &hrec);
7909     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7910
7911     query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
7912     r = do_query(hdb, query, &hrec);
7913     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
7914
7915     MsiCloseHandle(hdb);
7916     DeleteFileA(msifile);
7917 }
7918
7919 static void test_dbmerge(void)
7920 {
7921     static const WCHAR refdbW[] = {'r','e','f','d','b','.','m','s','i',0};
7922     MSIHANDLE hdb, href, hview, hrec;
7923     CHAR buf[MAX_PATH];
7924     LPCSTR query;
7925     DWORD size;
7926     UINT r;
7927
7928     r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
7929     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7930
7931     r = MsiOpenDatabaseW(refdbW, MSIDBOPEN_CREATE, &href);
7932     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7933
7934     /* hDatabase is invalid */
7935     r = MsiDatabaseMergeA(0, href, "MergeErrors");
7936     ok(r == ERROR_INVALID_HANDLE,
7937        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7938
7939     /* hDatabaseMerge is invalid */
7940     r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
7941     ok(r == ERROR_INVALID_HANDLE,
7942        "Expected ERROR_INVALID_HANDLE, got %d\n", r);
7943
7944     /* szTableName is NULL */
7945     r = MsiDatabaseMergeA(hdb, href, NULL);
7946     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7947
7948     /* szTableName is empty */
7949     r = MsiDatabaseMergeA(hdb, href, "");
7950     ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
7951
7952     /* both DBs empty, szTableName is valid */
7953     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7955
7956     query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
7957     r = run_query(hdb, 0, query);
7958     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7959
7960     query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
7961     r = run_query(href, 0, query);
7962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7963
7964     /* column types don't match */
7965     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
7966     ok(r == ERROR_DATATYPE_MISMATCH,
7967        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
7968
7969     /* nothing in MergeErrors */
7970     query = "SELECT * FROM `MergeErrors`";
7971     r = do_query(hdb, query, &hrec);
7972     ok(r == ERROR_BAD_QUERY_SYNTAX,
7973        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
7974
7975     query = "DROP TABLE `One`";
7976     r = run_query(hdb, 0, query);
7977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7978
7979     query = "DROP TABLE `One`";
7980     r = run_query(href, 0, query);
7981     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7982
7983     query = "CREATE TABLE `One` ( "
7984         "`A` CHAR(72), "
7985         "`B` CHAR(56), "
7986         "`C` CHAR(64) LOCALIZABLE, "
7987         "`D` LONGCHAR, "
7988         "`E` CHAR(72) NOT NULL, "
7989         "`F` CHAR(56) NOT NULL, "
7990         "`G` CHAR(64) NOT NULL LOCALIZABLE, "
7991         "`H` LONGCHAR NOT NULL "
7992         "PRIMARY KEY `A` )";
7993     r = run_query(hdb, 0, query);
7994     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
7995
7996     query = "CREATE TABLE `One` ( "
7997         "`A` CHAR(64), "
7998         "`B` CHAR(64), "
7999         "`C` CHAR(64), "
8000         "`D` CHAR(64), "
8001         "`E` CHAR(64) NOT NULL, "
8002         "`F` CHAR(64) NOT NULL, "
8003         "`G` CHAR(64) NOT NULL, "
8004         "`H` CHAR(64) NOT NULL "
8005         "PRIMARY KEY `A` )";
8006     r = run_query(href, 0, query);
8007     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8008
8009     /* column sting types don't match exactly */
8010     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8011     ok(r == ERROR_SUCCESS,
8012        "Expected ERROR_SUCCESS, got %d\n", r);
8013
8014     /* nothing in MergeErrors */
8015     query = "SELECT * FROM `MergeErrors`";
8016     r = do_query(hdb, query, &hrec);
8017     ok(r == ERROR_BAD_QUERY_SYNTAX,
8018        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8019
8020     query = "DROP TABLE `One`";
8021     r = run_query(hdb, 0, query);
8022     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8023
8024     query = "DROP TABLE `One`";
8025     r = run_query(href, 0, query);
8026     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8027
8028     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8029     r = run_query(hdb, 0, query);
8030     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8031
8032     query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
8033     r = run_query(href, 0, query);
8034     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8035
8036     /* column names don't match */
8037     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8038     ok(r == ERROR_DATATYPE_MISMATCH,
8039        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8040
8041     /* nothing in MergeErrors */
8042     query = "SELECT * FROM `MergeErrors`";
8043     r = do_query(hdb, query, &hrec);
8044     ok(r == ERROR_BAD_QUERY_SYNTAX,
8045        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8046
8047     query = "DROP TABLE `One`";
8048     r = run_query(hdb, 0, query);
8049     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8050
8051     query = "DROP TABLE `One`";
8052     r = run_query(href, 0, query);
8053     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8054
8055     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8056     r = run_query(hdb, 0, query);
8057     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8058
8059     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
8060     r = run_query(href, 0, query);
8061     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8062
8063     /* primary keys don't match */
8064     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8065     ok(r == ERROR_DATATYPE_MISMATCH,
8066        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8067
8068     /* nothing in MergeErrors */
8069     query = "SELECT * FROM `MergeErrors`";
8070     r = do_query(hdb, query, &hrec);
8071     ok(r == ERROR_BAD_QUERY_SYNTAX,
8072        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8073
8074     query = "DROP TABLE `One`";
8075     r = run_query(hdb, 0, query);
8076     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8077
8078     query = "DROP TABLE `One`";
8079     r = run_query(href, 0, query);
8080     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8081
8082     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8083     r = run_query(hdb, 0, query);
8084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8085
8086     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
8087     r = run_query(href, 0, query);
8088     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8089
8090     /* number of primary keys doesn't match */
8091     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8092     ok(r == ERROR_DATATYPE_MISMATCH,
8093        "Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
8094
8095     /* nothing in MergeErrors */
8096     query = "SELECT * FROM `MergeErrors`";
8097     r = do_query(hdb, query, &hrec);
8098     ok(r == ERROR_BAD_QUERY_SYNTAX,
8099        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8100
8101     query = "DROP TABLE `One`";
8102     r = run_query(hdb, 0, query);
8103     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8104
8105     query = "DROP TABLE `One`";
8106     r = run_query(href, 0, query);
8107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8108
8109     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8110     r = run_query(hdb, 0, query);
8111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8112
8113     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8114     r = run_query(href, 0, query);
8115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8116
8117     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8118     r = run_query(href, 0, query);
8119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8120
8121     /* number of columns doesn't match */
8122     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8123     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8124
8125     query = "SELECT * FROM `One`";
8126     r = do_query(hdb, query, &hrec);
8127     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8128
8129     r = MsiRecordGetInteger(hrec, 1);
8130     ok(r == 1, "Expected 1, got %d\n", r);
8131
8132     r = MsiRecordGetInteger(hrec, 2);
8133     ok(r == 2, "Expected 2, got %d\n", r);
8134
8135     r = MsiRecordGetInteger(hrec, 3);
8136     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8137
8138     MsiCloseHandle(hrec);
8139
8140     /* nothing in MergeErrors */
8141     query = "SELECT * FROM `MergeErrors`";
8142     r = do_query(hdb, query, &hrec);
8143     ok(r == ERROR_BAD_QUERY_SYNTAX,
8144        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8145
8146     query = "DROP TABLE `One`";
8147     r = run_query(hdb, 0, query);
8148     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8149
8150     query = "DROP TABLE `One`";
8151     r = run_query(href, 0, query);
8152     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8153
8154     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8155     r = run_query(hdb, 0, query);
8156     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8157
8158     query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
8159     r = run_query(href, 0, query);
8160     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8161
8162     query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8163     r = run_query(href, 0, query);
8164     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8165
8166     /* number of columns doesn't match */
8167     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8168     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8169
8170     query = "SELECT * FROM `One`";
8171     r = do_query(hdb, query, &hrec);
8172     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8173
8174     r = MsiRecordGetInteger(hrec, 1);
8175     ok(r == 1, "Expected 1, got %d\n", r);
8176
8177     r = MsiRecordGetInteger(hrec, 2);
8178     ok(r == 2, "Expected 2, got %d\n", r);
8179
8180     r = MsiRecordGetInteger(hrec, 3);
8181     ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
8182
8183     MsiCloseHandle(hrec);
8184
8185     /* nothing in MergeErrors */
8186     query = "SELECT * FROM `MergeErrors`";
8187     r = do_query(hdb, query, &hrec);
8188     ok(r == ERROR_BAD_QUERY_SYNTAX,
8189        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8190
8191     query = "DROP TABLE `One`";
8192     r = run_query(hdb, 0, query);
8193     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8194
8195     query = "DROP TABLE `One`";
8196     r = run_query(href, 0, query);
8197     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8198
8199     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8200     r = run_query(hdb, 0, query);
8201     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8202
8203     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 1 )";
8204     r = run_query(hdb, 0, query);
8205     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8206
8207     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
8208     r = run_query(hdb, 0, query);
8209     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8210
8211     query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
8212     r = run_query(href, 0, query);
8213     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8214
8215     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
8216     r = run_query(href, 0, query);
8217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8218
8219     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
8220     r = run_query(href, 0, query);
8221     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8222
8223     /* primary keys match, rows do not */
8224     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8225     ok(r == ERROR_FUNCTION_FAILED,
8226        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8227
8228     /* nothing in MergeErrors */
8229     query = "SELECT * FROM `MergeErrors`";
8230     r = do_query(hdb, query, &hrec);
8231     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8232
8233     size = MAX_PATH;
8234     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8235     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8236     ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
8237
8238     r = MsiRecordGetInteger(hrec, 2);
8239     ok(r == 2, "Expected 2, got %d\n", r);
8240
8241     MsiCloseHandle(hrec);
8242
8243     r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
8244     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8245
8246     r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
8247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8248
8249     size = MAX_PATH;
8250     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8251     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8252     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
8253
8254     size = MAX_PATH;
8255     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8256     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8257     ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
8258        "Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
8259
8260     MsiCloseHandle(hrec);
8261
8262     r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
8263     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8264
8265     size = MAX_PATH;
8266     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8267     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8268     ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
8269
8270     size = MAX_PATH;
8271     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8272     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8273     ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
8274
8275     MsiCloseHandle(hrec);
8276     MsiViewClose(hview);
8277     MsiCloseHandle(hview);
8278
8279     query = "DROP TABLE `MergeErrors`";
8280     r = run_query(hdb, 0, query);
8281     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8282
8283     query = "DROP TABLE `One`";
8284     r = run_query(hdb, 0, query);
8285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8286
8287     query = "DROP TABLE `One`";
8288     r = run_query(href, 0, query);
8289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8290
8291     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8292     r = run_query(href, 0, query);
8293     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8294
8295     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8296     r = run_query(href, 0, query);
8297     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8298
8299     /* table from merged database is not in target database */
8300     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8302
8303     query = "SELECT * FROM `One`";
8304     r = do_query(hdb, query, &hrec);
8305     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8306
8307     r = MsiRecordGetInteger(hrec, 1);
8308     ok(r == 1, "Expected 1, got %d\n", r);
8309
8310     size = MAX_PATH;
8311     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8313     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8314
8315     MsiCloseHandle(hrec);
8316
8317     /* nothing in MergeErrors */
8318     query = "SELECT * FROM `MergeErrors`";
8319     r = do_query(hdb, query, &hrec);
8320     ok(r == ERROR_BAD_QUERY_SYNTAX,
8321        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8322
8323     query = "DROP TABLE `One`";
8324     r = run_query(hdb, 0, query);
8325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8326
8327     query = "DROP TABLE `One`";
8328     r = run_query(href, 0, query);
8329     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8330
8331     query = "CREATE TABLE `One` ( "
8332             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8333     r = run_query(hdb, 0, query);
8334     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8335
8336     query = "CREATE TABLE `One` ( "
8337             "`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
8338     r = run_query(href, 0, query);
8339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8340
8341     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
8342     r = run_query(href, 0, query);
8343     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8344
8345     /* primary key is string */
8346     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8347     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8348
8349     query = "SELECT * FROM `One`";
8350     r = do_query(hdb, query, &hrec);
8351     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8352
8353     size = MAX_PATH;
8354     r = MsiRecordGetStringA(hrec, 1, buf, &size);
8355     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8356     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8357
8358     r = MsiRecordGetInteger(hrec, 2);
8359     ok(r == 1, "Expected 1, got %d\n", r);
8360
8361     MsiCloseHandle(hrec);
8362
8363     /* nothing in MergeErrors */
8364     query = "SELECT * FROM `MergeErrors`";
8365     r = do_query(hdb, query, &hrec);
8366     ok(r == ERROR_BAD_QUERY_SYNTAX,
8367        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8368
8369     create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
8370
8371     GetCurrentDirectoryA(MAX_PATH, buf);
8372     r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
8373     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8374
8375     query = "DROP TABLE `One`";
8376     r = run_query(hdb, 0, query);
8377     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8378
8379     query = "DROP TABLE `One`";
8380     r = run_query(href, 0, query);
8381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8382
8383     query = "CREATE TABLE `One` ( "
8384             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8385     r = run_query(hdb, 0, query);
8386     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8387
8388     query = "CREATE TABLE `One` ( "
8389             "`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
8390     r = run_query(href, 0, query);
8391     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8392
8393     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
8394     r = run_query(href, 0, query);
8395     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8396
8397     /* code page does not match */
8398     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8400
8401     query = "SELECT * FROM `One`";
8402     r = do_query(hdb, query, &hrec);
8403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8404
8405     r = MsiRecordGetInteger(hrec, 1);
8406     ok(r == 1, "Expected 1, got %d\n", r);
8407
8408     size = MAX_PATH;
8409     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8410     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8411     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
8412
8413     MsiCloseHandle(hrec);
8414
8415     /* nothing in MergeErrors */
8416     query = "SELECT * FROM `MergeErrors`";
8417     r = do_query(hdb, query, &hrec);
8418     ok(r == ERROR_BAD_QUERY_SYNTAX,
8419        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8420
8421     query = "DROP TABLE `One`";
8422     r = run_query(hdb, 0, query);
8423     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8424
8425     query = "DROP TABLE `One`";
8426     r = run_query(href, 0, query);
8427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8428
8429     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8430     r = run_query(hdb, 0, query);
8431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8432
8433     query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
8434     r = run_query(href, 0, query);
8435     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8436
8437     create_file("binary.dat");
8438     hrec = MsiCreateRecord(1);
8439     MsiRecordSetStreamA(hrec, 1, "binary.dat");
8440
8441     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
8442     r = run_query(href, hrec, query);
8443     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8444
8445     MsiCloseHandle(hrec);
8446
8447     /* binary data to merge */
8448     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8450
8451     query = "SELECT * FROM `One`";
8452     r = do_query(hdb, query, &hrec);
8453     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8454
8455     r = MsiRecordGetInteger(hrec, 1);
8456     ok(r == 1, "Expected 1, got %d\n", r);
8457
8458     size = MAX_PATH;
8459     ZeroMemory(buf, MAX_PATH);
8460     r = MsiRecordReadStream(hrec, 2, buf, &size);
8461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8462     ok(!lstrcmpA(buf, "binary.dat\n"),
8463        "Expected \"binary.dat\\n\", got \"%s\"\n", buf);
8464
8465     MsiCloseHandle(hrec);
8466
8467     /* nothing in MergeErrors */
8468     query = "SELECT * FROM `MergeErrors`";
8469     r = do_query(hdb, query, &hrec);
8470     ok(r == ERROR_BAD_QUERY_SYNTAX,
8471        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8472
8473     query = "DROP TABLE `One`";
8474     r = run_query(hdb, 0, query);
8475     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8476
8477     query = "DROP TABLE `One`";
8478     r = run_query(href, 0, query);
8479     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8480
8481     query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
8482     r = run_query(hdb, 0, query);
8483     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8484     r = run_query(href, 0, query);
8485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8486
8487     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
8488     r = run_query(href, 0, query);
8489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8490
8491     query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
8492     r = run_query(href, 0, query);
8493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8494
8495     r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
8496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8497
8498     query = "SELECT * FROM `One`";
8499     r = MsiDatabaseOpenViewA(hdb, query, &hview);
8500     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8501     r = MsiViewExecute(hview, 0);
8502     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8503
8504     r = MsiViewFetch(hview, &hrec);
8505     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8506
8507     r = MsiRecordGetInteger(hrec, 1);
8508     ok(r == 1, "Expected 1, got %d\n", r);
8509
8510     size = MAX_PATH;
8511     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8512     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8513     ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
8514
8515     MsiCloseHandle(hrec);
8516
8517     r = MsiViewFetch(hview, &hrec);
8518     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8519
8520     r = MsiRecordGetInteger(hrec, 1);
8521     ok(r == 2, "Expected 2, got %d\n", r);
8522
8523     size = MAX_PATH;
8524     r = MsiRecordGetStringA(hrec, 2, buf, &size);
8525     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8526     ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
8527
8528     MsiCloseHandle(hrec);
8529
8530     r = MsiViewFetch(hview, &hrec);
8531     ok(r == ERROR_NO_MORE_ITEMS,
8532        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8533
8534     MsiViewClose(hview);
8535     MsiCloseHandle(hview);
8536
8537     MsiCloseHandle(hdb);
8538     MsiCloseHandle(href);
8539     DeleteFileA(msifile);
8540     DeleteFileW(refdbW);
8541     DeleteFileA("codepage.idt");
8542     DeleteFileA("binary.dat");
8543 }
8544
8545 static void test_select_with_tablenames(void)
8546 {
8547     MSIHANDLE hdb, view, rec;
8548     LPCSTR query;
8549     UINT r;
8550     int i;
8551
8552     int vals[4][2] = {
8553         {1,12},
8554         {4,12},
8555         {1,15},
8556         {4,15}};
8557
8558     hdb = create_db();
8559     ok(hdb, "failed to create db\n");
8560
8561     /* Build a pair of tables with the same column names, but unique data */
8562     query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8563     r = run_query(hdb, 0, query);
8564     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8565
8566     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
8567     r = run_query(hdb, 0, query);
8568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8569
8570     query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
8571     r = run_query(hdb, 0, query);
8572     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8573
8574     query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
8575     r = run_query(hdb, 0, query);
8576     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8577
8578     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
8579     r = run_query(hdb, 0, query);
8580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8581
8582     query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
8583     r = run_query(hdb, 0, query);
8584     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8585
8586
8587     /* Test that selection based on prefixing the column with the table
8588      * actually selects the right data */
8589
8590     query = "SELECT T1.A, T2.B FROM T1,T2";
8591     r = MsiDatabaseOpenViewA(hdb, query, &view);
8592     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8593     r = MsiViewExecute(view, 0);
8594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8595
8596     for (i = 0; i < 4; i++)
8597     {
8598         r = MsiViewFetch(view, &rec);
8599         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8600
8601         r = MsiRecordGetInteger(rec, 1);
8602         ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
8603
8604         r = MsiRecordGetInteger(rec, 2);
8605         ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
8606
8607         MsiCloseHandle(rec);
8608     }
8609
8610     r = MsiViewFetch(view, &rec);
8611     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8612
8613     MsiViewClose(view);
8614     MsiCloseHandle(view);
8615     MsiCloseHandle(hdb);
8616     DeleteFileA(msifile);
8617 }
8618
8619 static const UINT ordervals[6][3] =
8620 {
8621     { MSI_NULL_INTEGER, 12, 13 },
8622     { 1, 2, 3 },
8623     { 6, 4, 5 },
8624     { 8, 9, 7 },
8625     { 10, 11, MSI_NULL_INTEGER },
8626     { 14, MSI_NULL_INTEGER, 15 }
8627 };
8628
8629 static void test_insertorder(void)
8630 {
8631     MSIHANDLE hdb, view, rec;
8632     LPCSTR query;
8633     UINT r;
8634     int i;
8635
8636     hdb = create_db();
8637     ok(hdb, "failed to create db\n");
8638
8639     query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
8640     r = run_query(hdb, 0, query);
8641     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8642
8643     query = "INSERT INTO `T` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
8644     r = run_query(hdb, 0, query);
8645     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8646
8647     query = "INSERT INTO `T` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
8648     r = run_query(hdb, 0, query);
8649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8650
8651     query = "INSERT INTO `T` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
8652     r = run_query(hdb, 0, query);
8653     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8654
8655     query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
8656     r = run_query(hdb, 0, query);
8657     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8658
8659     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
8660     r = run_query(hdb, 0, query);
8661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8662
8663     /* fails because the primary key already
8664      * has an MSI_NULL_INTEGER value set above
8665      */
8666     query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
8667     r = run_query(hdb, 0, query);
8668     ok(r == ERROR_FUNCTION_FAILED,
8669        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8670
8671     /* replicate the error where primary key is set twice */
8672     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
8673     r = run_query(hdb, 0, query);
8674     ok(r == ERROR_FUNCTION_FAILED,
8675        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
8676
8677     query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
8678     r = run_query(hdb, 0, query);
8679     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8680
8681     query = "INSERT INTO `T` VALUES ( 16 )";
8682     r = run_query(hdb, 0, query);
8683     ok(r == ERROR_BAD_QUERY_SYNTAX,
8684        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8685
8686     query = "INSERT INTO `T` VALUES ( 17, 18 )";
8687     r = run_query(hdb, 0, query);
8688     ok(r == ERROR_BAD_QUERY_SYNTAX,
8689        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8690
8691     query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
8692     r = run_query(hdb, 0, query);
8693     ok(r == ERROR_BAD_QUERY_SYNTAX,
8694        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
8695
8696     query = "SELECT * FROM `T`";
8697     r = MsiDatabaseOpenViewA(hdb, query, &view);
8698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8699     r = MsiViewExecute(view, 0);
8700     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8701
8702     for (i = 0; i < 6; i++)
8703     {
8704         r = MsiViewFetch(view, &rec);
8705         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8706
8707         r = MsiRecordGetInteger(rec, 1);
8708         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8709
8710         r = MsiRecordGetInteger(rec, 2);
8711         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8712
8713         r = MsiRecordGetInteger(rec, 3);
8714         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8715
8716         MsiCloseHandle(rec);
8717     }
8718
8719     r = MsiViewFetch(view, &rec);
8720     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8721
8722     MsiViewClose(view);
8723     MsiCloseHandle(view);
8724
8725     query = "DELETE FROM `T` WHERE `A` IS NULL";
8726     r = run_query(hdb, 0, query);
8727     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8728
8729     query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
8730     r = run_query(hdb, 0, query);
8731     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8732
8733     query = "SELECT * FROM `T`";
8734     r = MsiDatabaseOpenViewA(hdb, query, &view);
8735     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8736     r = MsiViewExecute(view, 0);
8737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8738
8739     for (i = 0; i < 6; i++)
8740     {
8741         r = MsiViewFetch(view, &rec);
8742         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8743
8744         r = MsiRecordGetInteger(rec, 1);
8745         ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
8746
8747         r = MsiRecordGetInteger(rec, 2);
8748         ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
8749
8750         r = MsiRecordGetInteger(rec, 3);
8751         ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
8752
8753         MsiCloseHandle(rec);
8754     }
8755
8756     r = MsiViewFetch(view, &rec);
8757     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
8758
8759     MsiViewClose(view);
8760     MsiCloseHandle(view);
8761     MsiCloseHandle(hdb);
8762     DeleteFileA(msifile);
8763 }
8764
8765 static void test_columnorder(void)
8766 {
8767     MSIHANDLE hdb, view, rec;
8768     char buf[MAX_PATH];
8769     LPCSTR query;
8770     DWORD sz;
8771     UINT r;
8772
8773     hdb = create_db();
8774     ok(hdb, "failed to create db\n");
8775
8776     /* Each column is a slot:
8777      * ---------------------
8778      * | B | C | A | E | D |
8779      * ---------------------
8780      *
8781      * When a column is selected as a primary key,
8782      * the column occupying the nth primary key slot is swapped
8783      * with the current position of the primary key in question:
8784      *
8785      * set primary key `D`
8786      * ---------------------    ---------------------
8787      * | B | C | A | E | D | -> | D | C | A | E | B |
8788      * ---------------------    ---------------------
8789      *
8790      * set primary key `E`
8791      * ---------------------    ---------------------
8792      * | D | C | A | E | B | -> | D | E | A | C | B |
8793      * ---------------------    ---------------------
8794      */
8795
8796     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
8797             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
8798             "PRIMARY KEY `D`, `E`)";
8799     r = run_query(hdb, 0, query);
8800     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8801
8802     query = "SELECT * FROM `T`";
8803     r = MsiDatabaseOpenViewA(hdb, query, &view);
8804     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8805
8806     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
8807     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8808
8809     sz = MAX_PATH;
8810     lstrcpyA(buf, "kiwi");
8811     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8812     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8813     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
8814
8815     sz = MAX_PATH;
8816     lstrcpyA(buf, "kiwi");
8817     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8818     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8819     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
8820
8821     sz = MAX_PATH;
8822     lstrcpyA(buf, "kiwi");
8823     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8824     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8825     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
8826
8827     sz = MAX_PATH;
8828     lstrcpyA(buf, "kiwi");
8829     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8830     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8831     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8832
8833     sz = MAX_PATH;
8834     lstrcpyA(buf, "kiwi");
8835     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8836     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8837     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
8838
8839     MsiCloseHandle(rec);
8840
8841     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
8842     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8843
8844     sz = MAX_PATH;
8845     lstrcpyA(buf, "kiwi");
8846     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8847     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8848     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8849
8850     sz = MAX_PATH;
8851     lstrcpyA(buf, "kiwi");
8852     r = MsiRecordGetStringA(rec, 2, buf, &sz);
8853     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8854     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8855
8856     sz = MAX_PATH;
8857     lstrcpyA(buf, "kiwi");
8858     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8860     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8861
8862     sz = MAX_PATH;
8863     lstrcpyA(buf, "kiwi");
8864     r = MsiRecordGetStringA(rec, 4, buf, &sz);
8865     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8866     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8867
8868     sz = MAX_PATH;
8869     lstrcpyA(buf, "kiwi");
8870     r = MsiRecordGetStringA(rec, 5, buf, &sz);
8871     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8872     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
8873
8874     MsiCloseHandle(rec);
8875     MsiViewClose(view);
8876     MsiCloseHandle(view);
8877
8878     query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
8879             "VALUES ( 1, 2, 'a', 3, 'bc' )";
8880     r = run_query(hdb, 0, query);
8881     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8882
8883     query = "SELECT * FROM `T`";
8884     r = do_query(hdb, query, &rec);
8885     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8886
8887     sz = MAX_PATH;
8888     lstrcpyA(buf, "kiwi");
8889     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8890     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8891     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
8892
8893     r = MsiRecordGetInteger(rec, 2);
8894     ok(r == 3, "Expected 3, got %d\n", r);
8895
8896     sz = MAX_PATH;
8897     lstrcpyA(buf, "kiwi");
8898     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8899     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8900     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
8901
8902     r = MsiRecordGetInteger(rec, 4);
8903     ok(r == 2, "Expected 2, got %d\n", r);
8904
8905     r = MsiRecordGetInteger(rec, 5);
8906     ok(r == 1, "Expected 1, got %d\n", r);
8907
8908     MsiCloseHandle(rec);
8909
8910     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
8911     r = MsiDatabaseOpenViewA(hdb, query, &view);
8912     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8913     r = MsiViewExecute(view, 0);
8914     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8915
8916     r = MsiViewFetch(view, &rec);
8917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8918
8919     sz = MAX_PATH;
8920     lstrcpyA(buf, "kiwi");
8921     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8922     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8923     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8924
8925     r = MsiRecordGetInteger(rec, 2);
8926     ok(r == 1, "Expected 1, got %d\n", r);
8927
8928     sz = MAX_PATH;
8929     lstrcpyA(buf, "kiwi");
8930     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8931     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8932     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
8933
8934     MsiCloseHandle(rec);
8935
8936     r = MsiViewFetch(view, &rec);
8937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8938
8939     sz = MAX_PATH;
8940     lstrcpyA(buf, "kiwi");
8941     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8942     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8943     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8944
8945     r = MsiRecordGetInteger(rec, 2);
8946     ok(r == 2, "Expected 2, got %d\n", r);
8947
8948     sz = MAX_PATH;
8949     lstrcpyA(buf, "kiwi");
8950     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8951     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8952     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
8953
8954     MsiCloseHandle(rec);
8955
8956     r = MsiViewFetch(view, &rec);
8957     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8958
8959     sz = MAX_PATH;
8960     lstrcpyA(buf, "kiwi");
8961     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8962     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8963     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8964
8965     r = MsiRecordGetInteger(rec, 2);
8966     ok(r == 3, "Expected 3, got %d\n", r);
8967
8968     sz = MAX_PATH;
8969     lstrcpyA(buf, "kiwi");
8970     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8971     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8972     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
8973
8974     MsiCloseHandle(rec);
8975
8976     r = MsiViewFetch(view, &rec);
8977     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8978
8979     sz = MAX_PATH;
8980     lstrcpyA(buf, "kiwi");
8981     r = MsiRecordGetStringA(rec, 1, buf, &sz);
8982     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8983     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
8984
8985     r = MsiRecordGetInteger(rec, 2);
8986     ok(r == 4, "Expected 4, got %d\n", r);
8987
8988     sz = MAX_PATH;
8989     lstrcpyA(buf, "kiwi");
8990     r = MsiRecordGetStringA(rec, 3, buf, &sz);
8991     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8992     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
8993
8994     MsiCloseHandle(rec);
8995
8996     r = MsiViewFetch(view, &rec);
8997     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
8998
8999     sz = MAX_PATH;
9000     lstrcpyA(buf, "kiwi");
9001     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9002     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9003     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9004
9005     r = MsiRecordGetInteger(rec, 2);
9006     ok(r == 5, "Expected 5, got %d\n", r);
9007
9008     sz = MAX_PATH;
9009     lstrcpyA(buf, "kiwi");
9010     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9011     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9012     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9013
9014     MsiCloseHandle(rec);
9015
9016     r = MsiViewFetch(view, &rec);
9017     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9018
9019     MsiViewClose(view);
9020     MsiCloseHandle(view);
9021
9022     query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
9023             "`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
9024             "PRIMARY KEY `C`, `A`, `D`)";
9025     r = run_query(hdb, 0, query);
9026     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9027
9028     query = "SELECT * FROM `Z`";
9029     r = MsiDatabaseOpenViewA(hdb, query, &view);
9030     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9031
9032     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
9033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9034
9035     sz = MAX_PATH;
9036     lstrcpyA(buf, "kiwi");
9037     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9038     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9039     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9040
9041     sz = MAX_PATH;
9042     lstrcpyA(buf, "kiwi");
9043     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9044     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9045     ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
9046
9047     sz = MAX_PATH;
9048     lstrcpyA(buf, "kiwi");
9049     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9051     ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
9052
9053     sz = MAX_PATH;
9054     lstrcpyA(buf, "kiwi");
9055     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9056     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9057     ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
9058
9059     sz = MAX_PATH;
9060     lstrcpyA(buf, "kiwi");
9061     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9062     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9063     ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
9064
9065     MsiCloseHandle(rec);
9066
9067     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
9068     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9069
9070     sz = MAX_PATH;
9071     lstrcpyA(buf, "kiwi");
9072     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9074     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9075
9076     sz = MAX_PATH;
9077     lstrcpyA(buf, "kiwi");
9078     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9079     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9080     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9081
9082     sz = MAX_PATH;
9083     lstrcpyA(buf, "kiwi");
9084     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9085     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9086     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9087
9088     sz = MAX_PATH;
9089     lstrcpyA(buf, "kiwi");
9090     r = MsiRecordGetStringA(rec, 4, buf, &sz);
9091     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9092     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9093
9094     sz = MAX_PATH;
9095     lstrcpyA(buf, "kiwi");
9096     r = MsiRecordGetStringA(rec, 5, buf, &sz);
9097     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9098     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9099
9100     MsiCloseHandle(rec);
9101     MsiViewClose(view);
9102     MsiCloseHandle(view);
9103
9104     query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
9105             "VALUES ( 1, 2, 'a', 3, 'bc' )";
9106     r = run_query(hdb, 0, query);
9107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9108
9109     query = "SELECT * FROM `Z`";
9110     r = do_query(hdb, query, &rec);
9111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9112
9113     r = MsiRecordGetInteger(rec, 1);
9114     ok(r == 2, "Expected 2, got %d\n", r);
9115
9116     sz = MAX_PATH;
9117     lstrcpyA(buf, "kiwi");
9118     r = MsiRecordGetStringA(rec, 2, buf, &sz);
9119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9120     ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
9121
9122     sz = MAX_PATH;
9123     lstrcpyA(buf, "kiwi");
9124     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9125     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9126     ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
9127
9128     r = MsiRecordGetInteger(rec, 4);
9129     ok(r == 3, "Expected 3, got %d\n", r);
9130
9131     r = MsiRecordGetInteger(rec, 5);
9132     ok(r == 1, "Expected 1, got %d\n", r);
9133
9134     MsiCloseHandle(rec);
9135
9136     query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
9137     r = MsiDatabaseOpenViewA(hdb, query, &view);
9138     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9139     r = MsiViewExecute(view, 0);
9140     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9141
9142     r = MsiViewFetch(view, &rec);
9143     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9144
9145     sz = MAX_PATH;
9146     lstrcpyA(buf, "kiwi");
9147     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9148     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9149     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9150
9151     r = MsiRecordGetInteger(rec, 2);
9152     ok(r == 1, "Expected 1, got %d\n", r);
9153
9154     sz = MAX_PATH;
9155     lstrcpyA(buf, "kiwi");
9156     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9157     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9158     ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
9159
9160     MsiCloseHandle(rec);
9161
9162     r = MsiViewFetch(view, &rec);
9163     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9164
9165     sz = MAX_PATH;
9166     lstrcpyA(buf, "kiwi");
9167     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9168     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9169     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9170
9171     r = MsiRecordGetInteger(rec, 2);
9172     ok(r == 2, "Expected 2, got %d\n", r);
9173
9174     sz = MAX_PATH;
9175     lstrcpyA(buf, "kiwi");
9176     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9177     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9178     ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
9179
9180     MsiCloseHandle(rec);
9181
9182     r = MsiViewFetch(view, &rec);
9183     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9184
9185     sz = MAX_PATH;
9186     lstrcpyA(buf, "kiwi");
9187     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9188     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9189     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9190
9191     r = MsiRecordGetInteger(rec, 2);
9192     ok(r == 3, "Expected 3, got %d\n", r);
9193
9194     sz = MAX_PATH;
9195     lstrcpyA(buf, "kiwi");
9196     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9197     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9198     ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
9199
9200     MsiCloseHandle(rec);
9201
9202     r = MsiViewFetch(view, &rec);
9203     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9204
9205     sz = MAX_PATH;
9206     lstrcpyA(buf, "kiwi");
9207     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9208     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9209     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9210
9211     r = MsiRecordGetInteger(rec, 2);
9212     ok(r == 4, "Expected 4, got %d\n", r);
9213
9214     sz = MAX_PATH;
9215     lstrcpyA(buf, "kiwi");
9216     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9217     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9218     ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
9219
9220     MsiCloseHandle(rec);
9221
9222     r = MsiViewFetch(view, &rec);
9223     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9224
9225     sz = MAX_PATH;
9226     lstrcpyA(buf, "kiwi");
9227     r = MsiRecordGetStringA(rec, 1, buf, &sz);
9228     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9229     ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
9230
9231     r = MsiRecordGetInteger(rec, 2);
9232     ok(r == 5, "Expected 5, got %d\n", r);
9233
9234     sz = MAX_PATH;
9235     lstrcpyA(buf, "kiwi");
9236     r = MsiRecordGetStringA(rec, 3, buf, &sz);
9237     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
9238     ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
9239
9240     MsiCloseHandle(rec);
9241
9242     r = MsiViewFetch(view, &rec);
9243     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
9244
9245     MsiViewClose(view);
9246     MsiCloseHandle(view);
9247
9248     MsiCloseHandle(hdb);
9249     DeleteFileA(msifile);
9250 }
9251
9252 static void test_createtable(void)
9253 {
9254     MSIHANDLE hdb, htab = 0, hrec = 0;
9255     LPCSTR query;
9256     UINT res;
9257     DWORD size;
9258     char buffer[0x20];
9259
9260     hdb = create_db();
9261     ok(hdb, "failed to create db\n");
9262
9263     query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
9264     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9265     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9266     if(res == ERROR_SUCCESS )
9267     {
9268         res = MsiViewExecute( htab, hrec );
9269         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9270
9271         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9272         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9273
9274         size = sizeof(buffer);
9275         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9276         todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9277         MsiCloseHandle( hrec );
9278
9279         res = MsiViewClose( htab );
9280         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9281
9282         res = MsiCloseHandle( htab );
9283         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9284     }
9285
9286     query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
9287     res = MsiDatabaseOpenViewA( hdb, query, &htab );
9288     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9289     if(res == ERROR_SUCCESS )
9290     {
9291         res = MsiViewExecute( htab, 0 );
9292         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9293
9294         res = MsiViewClose( htab );
9295         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9296
9297         res = MsiCloseHandle( htab );
9298         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9299
9300         query = "SELECT * FROM `a`";
9301         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9302         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9303
9304         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9305         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9306
9307         buffer[0] = 0;
9308         size = sizeof(buffer);
9309         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9310         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9311         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9312         MsiCloseHandle( hrec );
9313
9314         res = MsiViewClose( htab );
9315         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9316
9317         res = MsiCloseHandle( htab );
9318         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9319
9320         res = MsiDatabaseCommit(hdb);
9321         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9322
9323         res = MsiCloseHandle(hdb);
9324         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9325
9326         res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
9327         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9328
9329         query = "SELECT * FROM `a`";
9330         res = MsiDatabaseOpenViewA( hdb, query, &htab );
9331         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9332
9333         res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
9334         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9335
9336         buffer[0] = 0;
9337         size = sizeof(buffer);
9338         res = MsiRecordGetStringA(hrec, 1, buffer, &size );
9339         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9340         ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
9341
9342         res = MsiCloseHandle( hrec );
9343         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9344
9345         res = MsiViewClose( htab );
9346         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9347
9348         res = MsiCloseHandle( htab );
9349         ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9350     }
9351
9352     res = MsiDatabaseCommit(hdb);
9353     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9354
9355     res = MsiCloseHandle(hdb);
9356     ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
9357
9358     DeleteFileA(msifile);
9359 }
9360
9361 static void test_embedded_nulls(void)
9362 {
9363     static const char control_table[] =
9364         "Dialog\tText\n"
9365         "s72\tL0\n"
9366         "Control\tDialog\n"
9367         "LicenseAgreementDlg\ttext\x11\x19text\0text";
9368     UINT r, sz;
9369     MSIHANDLE hdb, hrec;
9370     char buffer[32];
9371
9372     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9373     ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
9374
9375     GetCurrentDirectoryA( MAX_PATH, CURR_DIR );
9376     write_file( "temp_file", control_table, sizeof(control_table) );
9377     r = MsiDatabaseImportA( hdb, CURR_DIR, "temp_file" );
9378     ok( r == ERROR_SUCCESS, "failed to import table %u\n", r );
9379     DeleteFileA( "temp_file" );
9380
9381     r = do_query( hdb, "SELECT `Text` FROM `Control` WHERE `Dialog` = 'LicenseAgreementDlg'", &hrec );
9382     ok( r == ERROR_SUCCESS, "query failed %u\n", r );
9383
9384     buffer[0] = 0;
9385     sz = sizeof(buffer);
9386     r = MsiRecordGetStringA( hrec, 1, buffer, &sz );
9387     ok( r == ERROR_SUCCESS, "failed to get string %u\n", r );
9388     ok( !memcmp( "text\r\ntext\ntext", buffer, sizeof("text\r\ntext\ntext") - 1 ), "wrong buffer contents \"%s\"\n", buffer );
9389
9390     MsiCloseHandle( hrec );
9391     MsiCloseHandle( hdb );
9392     DeleteFileA( msifile );
9393 }
9394
9395 static void test_select_column_names(void)
9396 {
9397     MSIHANDLE hdb = 0, rec, rec2, view;
9398     char buffer[32];
9399     UINT r, size;
9400
9401     DeleteFileA(msifile);
9402
9403     r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
9404     ok( r == ERROR_SUCCESS , "failed to open database: %u\n", r );
9405
9406     r = try_query( hdb, "CREATE TABLE `t` (`a` CHAR NOT NULL, `b` CHAR PRIMARY KEY `a`)");
9407     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9408
9409     r = try_query( hdb, "SELECT `t`.`b` FROM `t` WHERE `t`.`b` = `x`" );
9410     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9411
9412     r = try_query( hdb, "SELECT '', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9413     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9414
9415     r = try_query( hdb, "SELECT *, `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9416     todo_wine ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
9417
9418     r = try_query( hdb, "SELECT 'b', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
9419     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9420
9421     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x'" );
9422     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9423
9424     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY `b`" );
9425     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9426
9427     r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY 'b'" );
9428     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9429
9430     r = try_query( hdb, "SELECT 't'.'b' FROM `t` WHERE `t`.`b` = 'x'" );
9431     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9432
9433     r = try_query( hdb, "SELECT 'b' FROM `t` WHERE `t`.`b` = 'x'" );
9434     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9435
9436     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '1', '2' )" );
9437     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9438
9439     r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '3', '4' )" );
9440     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9441
9442     r = MsiDatabaseOpenViewA( hdb, "SELECT '' FROM `t`", &view );
9443     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9444
9445     r = MsiViewExecute( view, 0 );
9446     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9447
9448     r = MsiViewFetch( view, &rec );
9449     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9450     r = MsiRecordGetFieldCount( rec );
9451     ok( r == 1, "got %u\n",  r );
9452     r = MsiViewGetColumnInfo( view, MSICOLINFO_NAMES, &rec2 );
9453     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9454     r = MsiRecordGetFieldCount( rec2 );
9455     ok( r == 1, "got %u\n",  r );
9456     size = sizeof(buffer);
9457     memset( buffer, 0x55, sizeof(buffer) );
9458     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9459     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9460     ok( !buffer[0], "got \"%s\"\n", buffer );
9461     MsiCloseHandle( rec2 );
9462     r = MsiViewGetColumnInfo( view, MSICOLINFO_TYPES, &rec2 );
9463     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9464     r = MsiRecordGetFieldCount( rec2 );
9465     ok( r == 1, "got %u\n",  r );
9466     size = sizeof(buffer);
9467     memset( buffer, 0x55, sizeof(buffer) );
9468     r = MsiRecordGetStringA( rec2, 1, buffer, &size );
9469     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9470     ok( !lstrcmpA( buffer, "f0" ), "got \"%s\"\n", buffer );
9471     MsiCloseHandle( rec2 );
9472
9473     size = sizeof(buffer);
9474     memset( buffer, 0x55, sizeof(buffer) );
9475     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9476     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9477     ok( !buffer[0], "got \"%s\"\n", buffer );
9478     MsiCloseHandle( rec );
9479
9480     r = MsiViewFetch( view, &rec );
9481     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9482     size = sizeof(buffer);
9483     memset( buffer, 0x55, sizeof(buffer) );
9484     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9485     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9486     ok( !buffer[0], "got \"%s\"\n", buffer );
9487     MsiCloseHandle( rec );
9488
9489     r = MsiViewFetch( view, &rec );
9490     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9491     MsiCloseHandle( rec );
9492
9493     MsiViewClose( view );
9494     MsiCloseHandle( view );
9495
9496     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '' FROM `t`", &view );
9497     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9498
9499     r = MsiViewExecute( view, 0 );
9500     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9501
9502     r = MsiViewFetch( view, &rec );
9503     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9504     r = MsiRecordGetFieldCount( rec );
9505     ok( r == 2, "got %u\n",  r );
9506     size = sizeof(buffer);
9507     memset( buffer, 0x55, sizeof(buffer) );
9508     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9509     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9510     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9511     MsiCloseHandle( rec );
9512
9513     r = MsiViewFetch( view, &rec );
9514     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9515     size = sizeof(buffer);
9516     memset( buffer, 0x55, sizeof(buffer) );
9517     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9518     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9519     ok( !buffer[0], "got \"%s\"\n", buffer );
9520     MsiCloseHandle( rec );
9521
9522     r = MsiViewFetch( view, &rec );
9523     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9524     MsiCloseHandle( rec );
9525
9526     MsiViewClose( view );
9527     MsiCloseHandle( view );
9528
9529     r = MsiDatabaseOpenViewA( hdb, "SELECT '', `a` FROM `t`", &view );
9530     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9531
9532     r = MsiViewExecute( view, 0 );
9533     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9534
9535     r = MsiViewFetch( view, &rec );
9536     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9537     r = MsiRecordGetFieldCount( rec );
9538     ok( r == 2, "got %u\n",  r );
9539     size = sizeof(buffer);
9540     memset( buffer, 0x55, sizeof(buffer) );
9541     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9542     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9543     ok( !buffer[0], "got \"%s\"\n", buffer );
9544     size = sizeof(buffer);
9545     memset( buffer, 0x55, sizeof(buffer) );
9546     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9547     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9548     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9549     MsiCloseHandle( rec );
9550
9551     r = MsiViewFetch( view, &rec );
9552     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9553     size = sizeof(buffer);
9554     memset( buffer, 0x55, sizeof(buffer) );
9555     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9556     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9557     ok( !buffer[0], "got \"%s\"\n", buffer );
9558     size = sizeof(buffer);
9559     memset( buffer, 0x55, sizeof(buffer) );
9560     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9561     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9562     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9563     MsiCloseHandle( rec );
9564
9565     r = MsiViewFetch( view, &rec );
9566     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9567     MsiCloseHandle( rec );
9568
9569     MsiViewClose( view );
9570     MsiCloseHandle( view );
9571
9572     r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '', `b` FROM `t`", &view );
9573     ok( r == ERROR_SUCCESS, "failed to open database view: %u\n", r );
9574
9575     r = MsiViewExecute( view, 0 );
9576     ok( r == ERROR_SUCCESS, "failed to execute view: %u\n", r );
9577
9578     r = MsiViewFetch( view, &rec );
9579     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9580     r = MsiRecordGetFieldCount( rec );
9581     ok( r == 3, "got %u\n",  r );
9582     size = sizeof(buffer);
9583     memset( buffer, 0x55, sizeof(buffer) );
9584     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9585     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9586     ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
9587     size = sizeof(buffer);
9588     memset( buffer, 0x55, sizeof(buffer) );
9589     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9590     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9591     ok( !buffer[0], "got \"%s\"\n", buffer );
9592     size = sizeof(buffer);
9593     memset( buffer, 0x55, sizeof(buffer) );
9594     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9595     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9596     ok( !lstrcmpA( buffer, "2" ), "got \"%s\"\n", buffer );
9597     MsiCloseHandle( rec );
9598
9599     r = MsiViewFetch( view, &rec );
9600     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9601     size = sizeof(buffer);
9602     memset( buffer, 0x55, sizeof(buffer) );
9603     r = MsiRecordGetStringA( rec, 1, buffer, &size );
9604     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9605     ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
9606     size = sizeof(buffer);
9607     memset( buffer, 0x55, sizeof(buffer) );
9608     r = MsiRecordGetStringA( rec, 2, buffer, &size );
9609     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9610     ok( !buffer[0], "got \"%s\"\n", buffer );
9611     size = sizeof(buffer);
9612     memset( buffer, 0x55, sizeof(buffer) );
9613     r = MsiRecordGetStringA( rec, 3, buffer, &size );
9614     ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
9615     ok( !lstrcmpA( buffer, "4" ), "got \"%s\"\n", buffer );
9616     MsiCloseHandle( rec );
9617
9618     r = MsiViewFetch( view, &rec );
9619     ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
9620     MsiCloseHandle( rec );
9621
9622     MsiViewClose( view );
9623     MsiCloseHandle( view );
9624
9625     r = try_query( hdb, "SELECT '' FROM `t` WHERE `t`.`b` = 'x'" );
9626     ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
9627
9628     r = try_query( hdb, "SELECT `` FROM `t` WHERE `t`.`b` = 'x'" );
9629     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9630
9631     r = try_query( hdb, "SELECT `b` FROM 't' WHERE `t`.`b` = 'x'" );
9632     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9633
9634     r = try_query( hdb, "SELECT `b` FROM `t` WHERE 'b' = 'x'" );
9635     ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9636
9637     r = try_query( hdb, "SELECT `t`.`b`, `` FROM `t` WHERE `t`.`b` = 'x'" );
9638     todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
9639
9640     r = MsiCloseHandle( hdb );
9641     ok(r == ERROR_SUCCESS , "failed to close database: %u\n", r);
9642 }
9643
9644 START_TEST(db)
9645 {
9646     test_msidatabase();
9647     test_msiinsert();
9648     test_msidecomposedesc();
9649     test_msibadqueries();
9650     test_viewmodify();
9651     test_viewgetcolumninfo();
9652     test_getcolinfo();
9653     test_msiexport();
9654     test_longstrings();
9655     test_streamtable();
9656     test_binary();
9657     test_where_not_in_selected();
9658     test_where();
9659     test_msiimport();
9660     test_binary_import();
9661     test_markers();
9662     test_handle_limit();
9663     test_try_transform();
9664     test_join();
9665     test_temporary_table();
9666     test_alter();
9667     test_integers();
9668     test_update();
9669     test_special_tables();
9670     test_tables_order();
9671     test_rows_order();
9672     test_select_markers();
9673     test_viewmodify_update();
9674     test_viewmodify_assign();
9675     test_stringtable();
9676     test_viewmodify_delete();
9677     test_defaultdatabase();
9678     test_order();
9679     test_viewmodify_delete_temporary();
9680     test_deleterow();
9681     test_quotes();
9682     test_carriagereturn();
9683     test_noquotes();
9684     test_forcecodepage();
9685     test_viewmodify_refresh();
9686     test_where_viewmodify();
9687     test_storages_table();
9688     test_dbtopackage();
9689     test_droptable();
9690     test_dbmerge();
9691     test_select_with_tablenames();
9692     test_insertorder();
9693     test_columnorder();
9694     test_suminfo_import();
9695     test_createtable();
9696     test_collation();
9697     test_embedded_nulls();
9698     test_select_column_names();
9699 }