dlls/msi/tests/db.c

   1 /*
   2  * Copyright (C) 2005 Mike McCormack for CodeWeavers
   3  *
   4  * A test program for MSI database files.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdio.h>
  24
  25 #include <windows.h>
  26 #include <msi.h>
  27 #include <msiquery.h>
  28
  29 #include <objidl.h>
  30
  31 #include "wine/test.h"
  32
  33 static const char *msifile = "winetest.msi";
  34 static const char *msifile2 = "winetst2.msi";
  35 static const char *mstfile = "winetst.mst";
  36
  37 static void test_msidatabase(void)
  38 {
  39     MSIHANDLE hdb = 0, hdb2 = 0;
  40     UINT res;
  41
  42     DeleteFile(msifile);
  43
  44     res = MsiOpenDatabase( msifile, msifile2, &hdb );
  45     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  46
  47     res = MsiOpenDatabase( msifile, (LPSTR) 0xff, &hdb );
  48     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  49
  50     res = MsiCloseHandle( hdb );
  51     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  52
  53     /* create an empty database */
  54     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
  55     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  56
  57     res = MsiDatabaseCommit( hdb );
  58     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  59
  60     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
  61
  62     res = MsiCloseHandle( hdb );
  63     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  64     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  65     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  66
  67     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "database should exist\n");
  68
  69     res = MsiDatabaseCommit( hdb2 );
  70     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  71
  72     res = MsiCloseHandle( hdb2 );
  73     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  74
  75     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  76     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  77
  78     res = MsiCloseHandle( hdb2 );
  79     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  80
  81     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile2 ), "uncommitted database should not exist\n");
  82
  83     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  84     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  85
  86     res = MsiDatabaseCommit( hdb2 );
  87     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  88
  89     res = MsiCloseHandle( hdb2 );
  90     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  91
  92     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "committed database should exist\n");
  93
  94     res = MsiOpenDatabase( msifile, MSIDBOPEN_READONLY, &hdb );
  95     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  96
  97     res = MsiCloseHandle( hdb );
  98     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  99
 100     res = MsiOpenDatabase( msifile, MSIDBOPEN_DIRECT, &hdb );
 101     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 102
 103     res = MsiCloseHandle( hdb );
 104     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 105
 106     res = MsiOpenDatabase( msifile, MSIDBOPEN_TRANSACT, &hdb );
 107     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 108
 109     res = MsiCloseHandle( hdb );
 110     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 111     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 112
 113     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 114     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 115     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 116
 117     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 118
 119     res = MsiCloseHandle( hdb );
 120     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 121
 122     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile ), "database should exist\n");
 123
 124     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 125     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 126
 127     res = MsiDatabaseCommit( hdb );
 128     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 129
 130     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 131
 132     res = MsiCloseHandle( hdb );
 133     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 134
 135     res = DeleteFile( msifile2 );
 136     ok( res == TRUE, "Failed to delete database\n" );
 137
 138     res = DeleteFile( msifile );
 139     ok( res == TRUE, "Failed to delete database\n" );
 140 }
 141
 142 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 143 {
 144     MSIHANDLE hview = 0;
 145     UINT r, ret;
 146
 147     /* open a select query */
 148     r = MsiDatabaseOpenView(hdb, query, &hview);
 149     if (r != ERROR_SUCCESS)
 150         return r;
 151     r = MsiViewExecute(hview, 0);
 152     if (r != ERROR_SUCCESS)
 153         return r;
 154     ret = MsiViewFetch(hview, phrec);
 155     r = MsiViewClose(hview);
 156     if (r != ERROR_SUCCESS)
 157         return r;
 158     r = MsiCloseHandle(hview);
 159     if (r != ERROR_SUCCESS)
 160         return r;
 161     return ret;
 162 }
 163
 164 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 165 {
 166     MSIHANDLE hview = 0;
 167     UINT r;
 168
 169     r = MsiDatabaseOpenView(hdb, query, &hview);
 170     if( r != ERROR_SUCCESS )
 171         return r;
 172
 173     r = MsiViewExecute(hview, hrec);
 174     if( r == ERROR_SUCCESS )
 175         r = MsiViewClose(hview);
 176     MsiCloseHandle(hview);
 177     return r;
 178 }
 179
 180 static UINT create_component_table( MSIHANDLE hdb )
 181 {
 182     return run_query( hdb, 0,
 183             "CREATE TABLE `Component` ( "
 184             "`Component` CHAR(72) NOT NULL, "
 185             "`ComponentId` CHAR(38), "
 186             "`Directory_` CHAR(72) NOT NULL, "
 187             "`Attributes` SHORT NOT NULL, "
 188             "`Condition` CHAR(255), "
 189             "`KeyPath` CHAR(72) "
 190             "PRIMARY KEY `Component`)" );
 191 }
 192
 193 static UINT create_feature_components_table( MSIHANDLE hdb )
 194 {
 195     return run_query( hdb, 0,
 196             "CREATE TABLE `FeatureComponents` ( "
 197             "`Feature_` CHAR(38) NOT NULL, "
 198             "`Component_` CHAR(72) NOT NULL "
 199             "PRIMARY KEY `Feature_`, `Component_` )" );
 200 }
 201
 202 static UINT create_std_dlls_table( MSIHANDLE hdb )
 203 {
 204     return run_query( hdb, 0,
 205             "CREATE TABLE `StdDlls` ( "
 206             "`File` CHAR(255) NOT NULL, "
 207             "`Binary_` CHAR(72) NOT NULL "
 208             "PRIMARY KEY `File` )" );
 209 }
 210
 211 static UINT create_binary_table( MSIHANDLE hdb )
 212 {
 213     return run_query( hdb, 0,
 214             "CREATE TABLE `Binary` ( "
 215             "`Name` CHAR(72) NOT NULL, "
 216             "`Data` CHAR(72) NOT NULL "
 217             "PRIMARY KEY `Name` )" );
 218 }
 219
 220 static UINT add_component_entry( MSIHANDLE hdb, const char *values )
 221 {
 222     char insert[] = "INSERT INTO `Component`  "
 223             "(`Component`, `ComponentId`, `Directory_`, `Attributes`, `Condition`, `KeyPath`) "
 224             "VALUES( %s )";
 225     char *query;
 226     UINT sz, r;
 227
 228     sz = strlen(values) + sizeof insert;
 229     query = HeapAlloc(GetProcessHeap(),0,sz);
 230     sprintf(query,insert,values);
 231     r = run_query( hdb, 0, query );
 232     HeapFree(GetProcessHeap(), 0, query);
 233     return r;
 234 }
 235
 236 static UINT add_feature_components_entry( MSIHANDLE hdb, const char *values )
 237 {
 238     char insert[] = "INSERT INTO `FeatureComponents` "
 239             "(`Feature_`, `Component_`) "
 240             "VALUES( %s )";
 241     char *query;
 242     UINT sz, r;
 243
 244     sz = strlen(values) + sizeof insert;
 245     query = HeapAlloc(GetProcessHeap(),0,sz);
 246     sprintf(query,insert,values);
 247     r = run_query( hdb, 0, query );
 248     HeapFree(GetProcessHeap(), 0, query);
 249     return r;
 250 }
 251
 252 static UINT add_std_dlls_entry( MSIHANDLE hdb, const char *values )
 253 {
 254     char insert[] = "INSERT INTO `StdDlls` "
 255             "(`File`, `Binary_`) "
 256             "VALUES( %s )";
 257     char *query;
 258     UINT sz, r;
 259
 260     sz = strlen(values) + sizeof insert;
 261     query = HeapAlloc(GetProcessHeap(),0,sz);
 262     sprintf(query,insert,values);
 263     r = run_query( hdb, 0, query );
 264     HeapFree(GetProcessHeap(), 0, query);
 265     return r;
 266 }
 267
 268 static UINT add_binary_entry( MSIHANDLE hdb, const char *values )
 269 {
 270     char insert[] = "INSERT INTO `Binary` "
 271             "(`Name`, `Data`) "
 272             "VALUES( %s )";
 273     char *query;
 274     UINT sz, r;
 275
 276     sz = strlen(values) + sizeof insert;
 277     query = HeapAlloc(GetProcessHeap(),0,sz);
 278     sprintf(query,insert,values);
 279     r = run_query( hdb, 0, query );
 280     HeapFree(GetProcessHeap(), 0, query);
 281     return r;
 282 }
 283
 284 static void test_msiinsert(void)
 285 {
 286     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 287     UINT r;
 288     const char *query;
 289     char buf[80];
 290     DWORD sz;
 291
 292     DeleteFile(msifile);
 293
 294     /* just MsiOpenDatabase should not create a file */
 295     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 296     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 297
 298     /* create a table */
 299     query = "CREATE TABLE `phone` ( "
 300             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 301             "PRIMARY KEY `id`)";
 302     r = MsiDatabaseOpenView(hdb, query, &hview);
 303     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 304     r = MsiViewExecute(hview, 0);
 305     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 306     r = MsiViewClose(hview);
 307     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 308     r = MsiCloseHandle(hview);
 309     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 310
 311     /* insert a value into it */
 312     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 313         "VALUES('1', 'Abe', '8675309')";
 314     r = MsiDatabaseOpenView(hdb, query, &hview);
 315     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 316     r = MsiViewExecute(hview, 0);
 317     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 318     r = MsiViewClose(hview);
 319     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 320     r = MsiCloseHandle(hview);
 321     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 322
 323     query = "SELECT * FROM `phone` WHERE `id` = 1";
 324     r = do_query(hdb, query, &hrec);
 325     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 326
 327     /* check the record contains what we put in it */
 328     r = MsiRecordGetFieldCount(hrec);
 329     ok(r == 3, "record count wrong\n");
 330
 331     todo_wine {
 332     r = MsiRecordIsNull(hrec, 0);
 333     ok(r == FALSE, "field 0 not null\n");
 334     }
 335
 336     r = MsiRecordGetInteger(hrec, 1);
 337     ok(r == 1, "field 1 contents wrong\n");
 338     sz = sizeof buf;
 339     r = MsiRecordGetString(hrec, 2, buf, &sz);
 340     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 341     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 342     sz = sizeof buf;
 343     r = MsiRecordGetString(hrec, 3, buf, &sz);
 344     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 345     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 346
 347     r = MsiCloseHandle(hrec);
 348     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 349
 350     /* open a select query */
 351     hrec = 100;
 352     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 353     r = do_query(hdb, query, &hrec);
 354     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 355     ok(hrec == 0, "hrec should be null\n");
 356
 357     r = MsiCloseHandle(hrec);
 358     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 359
 360     query = "SELECT * FROM `phone` WHERE `id` < 0";
 361     r = do_query(hdb, query, &hrec);
 362     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 363
 364     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 365     r = do_query(hdb, query, &hrec);
 366     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 367
 368     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 369     r = do_query(hdb, query, &hrec);
 370     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 371
 372     query = "SELECT * FROM `phone` WHERE `id` > 10";
 373     r = do_query(hdb, query, &hrec);
 374     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 375
 376     /* now try a few bad INSERT xqueries */
 377     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 378         "VALUES(?, ?)";
 379     r = MsiDatabaseOpenView(hdb, query, &hview);
 380     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 381
 382     /* construct a record to insert */
 383     hrec = MsiCreateRecord(4);
 384     r = MsiRecordSetInteger(hrec, 1, 2);
 385     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 386     r = MsiRecordSetString(hrec, 2, "Adam");
 387     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 388     r = MsiRecordSetString(hrec, 3, "96905305");
 389     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 390
 391     /* insert another value, using a record and wildcards */
 392     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 393         "VALUES(?, ?, ?)";
 394     r = MsiDatabaseOpenView(hdb, query, &hview);
 395     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 396
 397     if (r == ERROR_SUCCESS)
 398     {
 399         r = MsiViewExecute(hview, hrec);
 400         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 401         r = MsiViewClose(hview);
 402         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 403         r = MsiCloseHandle(hview);
 404         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 405     }
 406     r = MsiCloseHandle(hrec);
 407     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 408
 409     r = MsiViewFetch(0, NULL);
 410     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 411
 412     r = MsiDatabaseCommit(hdb);
 413     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 414
 415     r = MsiCloseHandle(hdb);
 416     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 417
 418     r = DeleteFile(msifile);
 419     ok(r == TRUE, "file didn't exist after commit\n");
 420 }
 421
 422 typedef UINT (WINAPI *fnMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 423 static fnMsiDecomposeDescriptorA pMsiDecomposeDescriptorA;
 424
 425 static void test_msidecomposedesc(void)
 426 {
 427     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 428     const char *desc;
 429     UINT r;
 430     DWORD len;
 431     HMODULE hmod;
 432
 433     hmod = GetModuleHandle("msi.dll");
 434     pMsiDecomposeDescriptorA = (fnMsiDecomposeDescriptorA)
 435         GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 436     if (!pMsiDecomposeDescriptorA)
 437         return;
 438
 439     /* test a valid feature descriptor */
 440     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 441     len = 0;
 442     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 443     ok(r == ERROR_SUCCESS, "returned an error\n");
 444     ok(len == strlen(desc), "length was wrong\n");
 445     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 446     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 447     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 448
 449     /* test an invalid feature descriptor with too many characters */
 450     desc = "']gAVn-}f(ZXfeAR6.ji"
 451            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 452            "3w2x^IGfe?CxI5heAvk.";
 453     len = 0;
 454     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 455     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 456
 457     /*
 458      * Test a valid feature descriptor with the
 459      * maximum number of characters and some trailing characters.
 460      */
 461     desc = "']gAVn-}f(ZXfeAR6.ji"
 462            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 463            "3w2x^IGfe?CxI5heAvk."
 464            "extra";
 465     len = 0;
 466     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 467     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 468     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 469
 470     len = 0;
 471     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 472     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 473     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 474
 475     len = 0;
 476     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 477     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 478     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 479
 480     len = 0;
 481     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 482     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 483     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 484
 485     len = 0;
 486     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 487     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 488     ok(len == 0, "length wrong\n");
 489 }
 490
 491 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 492 {
 493     MSIHANDLE htab = 0;
 494     UINT res;
 495
 496     res = MsiDatabaseOpenView( hdb, szQuery, &htab );
 497     if(res == ERROR_SUCCESS )
 498     {
 499         UINT r;
 500
 501         r = MsiViewExecute( htab, hrec );
 502         if(r != ERROR_SUCCESS )
 503             res = r;
 504
 505         r = MsiViewClose( htab );
 506         if(r != ERROR_SUCCESS )
 507             res = r;
 508
 509         r = MsiCloseHandle( htab );
 510         if(r != ERROR_SUCCESS )
 511             res = r;
 512     }
 513     return res;
 514 }
 515
 516 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 517 {
 518     return try_query_param( hdb, szQuery, 0 );
 519 }
 520
 521 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 522 {
 523     MSIHANDLE hrec = 0;
 524     UINT r;
 525
 526     hrec = MsiCreateRecord( 1 );
 527     MsiRecordSetString( hrec, 1, "Hello");
 528
 529     r = try_query_param( hdb, szQuery, hrec );
 530
 531     MsiCloseHandle( hrec );
 532     return r;
 533 }
 534
 535 static void test_msibadqueries(void)
 536 {
 537     MSIHANDLE hdb = 0;
 538     UINT r;
 539
 540     DeleteFile(msifile);
 541
 542     /* just MsiOpenDatabase should not create a file */
 543     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 544     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 545
 546     r = MsiDatabaseCommit( hdb );
 547     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 548
 549     r = MsiCloseHandle( hdb );
 550     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 551
 552     /* open it readonly */
 553     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb );
 554     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 555
 556     /* add a table to it */
 557     r = try_query( hdb, "select * from _Tables");
 558     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 559
 560     r = MsiCloseHandle( hdb );
 561     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 562
 563     /* open it read/write */
 564     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
 565     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 566
 567     /* a bunch of test queries that fail with the native MSI */
 568
 569     r = try_query( hdb, "CREATE TABLE");
 570     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 571
 572     r = try_query( hdb, "CREATE TABLE `a`");
 573     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 574
 575     r = try_query( hdb, "CREATE TABLE `a` ()");
 576     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 577
 578     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 579     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 580
 581     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 582     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 583
 584     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 585     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 586
 587     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 588     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 589
 590     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 591     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 592
 593     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 594     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 595
 596     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 597     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 598
 599     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 600     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 601
 602     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 603     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 604
 605     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 606     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 607
 608     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 609     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 610
 611     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 612     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 613
 614     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 615     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 616
 617     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 618     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 619
 620     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 621     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 622
 623     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 624     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 625
 626     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 627           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 628     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 629
 630     r = MsiDatabaseCommit( hdb );
 631     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 632
 633     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 634                           "PRIMARY KEY `foo`)");
 635     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 636
 637     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 638     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 639
 640     r = MsiDatabaseCommit( hdb );
 641     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 642
 643     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 644                           "PRIMARY KEY `ba`)");
 645     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 646
 647     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 648     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 649
 650     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 651                           "PRIMARY KEY `t`)");
 652     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 653
 654     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 655     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 656
 657     r = try_query( hdb, "select * from c");
 658     ok(r == ERROR_SUCCESS , "query failed\n");
 659
 660     r = try_query( hdb, "select * from c where b = 'x");
 661     todo_wine ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 662
 663     r = try_query( hdb, "select * from 'c'");
 664     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 665
 666     r = try_query( hdb, "select * from ''");
 667     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 668
 669     r = try_query( hdb, "select * from c where b = x");
 670     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 671
 672     r = try_query( hdb, "select * from c where b = \"x\"");
 673     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 674
 675     r = try_query( hdb, "select * from c where b = 'x'");
 676     ok(r == ERROR_SUCCESS, "query failed\n");
 677
 678     r = try_query( hdb, "select * from c where b = '\"x'");
 679     ok(r == ERROR_SUCCESS, "query failed\n");
 680
 681     if (0)  /* FIXME: this query causes trouble with other tests */
 682     {
 683         r = try_query( hdb, "select * from c where b = '\\\'x'");
 684         ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 685     }
 686
 687     r = try_query( hdb, "select * from 'c'");
 688     ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 689
 690     r = MsiCloseHandle( hdb );
 691     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 692
 693     r = DeleteFile( msifile );
 694     ok(r == TRUE, "file didn't exist after commit\n");
 695 }
 696
 697 static void test_viewmodify(void)
 698 {
 699     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 700     UINT r;
 701     MSIDBERROR err;
 702     const char *query;
 703     char buffer[0x100];
 704     DWORD sz;
 705
 706     DeleteFile(msifile);
 707
 708     /* just MsiOpenDatabase should not create a file */
 709     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 710     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 711
 712     query = "CREATE TABLE `phone` ( "
 713             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 714             "PRIMARY KEY `id`)";
 715     r = run_query( hdb, 0, query );
 716     ok(r == ERROR_SUCCESS, "query failed\n");
 717
 718     /* check what the error function reports without doing anything */
 719     sz = 0;
 720     /* passing NULL as the 3rd param make function to crash on older platforms */
 721     err = MsiViewGetError( 0, NULL, &sz );
 722     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 723
 724     /* open a view */
 725     query = "SELECT * FROM `phone`";
 726     r = MsiDatabaseOpenView(hdb, query, &hview);
 727     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 728
 729     /* see what happens with a good hview and bad args */
 730     err = MsiViewGetError( hview, NULL, NULL );
 731     ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
 732        "MsiViewGetError returns %u (expected -3)\n", err);
 733     err = MsiViewGetError( hview, buffer, NULL );
 734     ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 735
 736     /* see what happens with a zero length buffer */
 737     sz = 0;
 738     buffer[0] = 'x';
 739     err = MsiViewGetError( hview, buffer, &sz );
 740     ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 741     ok(buffer[0] == 'x', "buffer cleared\n");
 742     ok(sz == 0, "size not zero\n");
 743
 744     /* ok this one is strange */
 745     sz = 0;
 746     err = MsiViewGetError( hview, NULL, &sz );
 747     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 748     ok(sz == 0, "size not zero\n");
 749
 750     /* see if it really has an error */
 751     sz = sizeof buffer;
 752     buffer[0] = 'x';
 753     err = MsiViewGetError( hview, buffer, &sz );
 754     ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 755     ok(buffer[0] == 0, "buffer not cleared\n");
 756     ok(sz == 0, "size not zero\n");
 757
 758     r = MsiViewExecute(hview, 0);
 759     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 760
 761     /* try some invalid records */
 762     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 763     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 764     r = MsiViewModify(hview, -1, 0 );
 765     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 766
 767     /* try an small record */
 768     hrec = MsiCreateRecord(1);
 769     r = MsiViewModify(hview, -1, hrec );
 770     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 771
 772     r = MsiCloseHandle(hrec);
 773     ok(r == ERROR_SUCCESS, "failed to close record\n");
 774
 775     /* insert a valid record */
 776     hrec = MsiCreateRecord(3);
 777
 778     r = MsiRecordSetInteger(hrec, 1, 1);
 779     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 780     r = MsiRecordSetString(hrec, 2, "bob");
 781     ok(r == ERROR_SUCCESS, "failed to set string\n");
 782     r = MsiRecordSetString(hrec, 3, "7654321");
 783     ok(r == ERROR_SUCCESS, "failed to set string\n");
 784
 785     r = MsiViewExecute(hview, 0);
 786     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 787     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 788     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 789
 790     /* insert the same thing again */
 791     r = MsiViewExecute(hview, 0);
 792     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 793
 794     /* should fail ... */
 795     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 796     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 797
 798     r = MsiCloseHandle(hrec);
 799     ok(r == ERROR_SUCCESS, "failed to close record\n");
 800
 801     r = MsiViewClose(hview);
 802     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 803     r = MsiCloseHandle(hview);
 804     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 805
 806     query = "SELECT * FROM `phone`";
 807     r = MsiDatabaseOpenView(hdb, query, &hview);
 808     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 809
 810     r = MsiViewExecute(hview, 0);
 811     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 812
 813     r = MsiViewFetch(hview, &hrec);
 814     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 815
 816     r = MsiRecordGetInteger(hrec, 1);
 817     ok(r == 1, "Expected 1, got %d\n", r);
 818
 819     sz = sizeof(buffer);
 820     r = MsiRecordGetString(hrec, 2, buffer, &sz);
 821     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 822     ok(!lstrcmp(buffer, "bob"), "Expected bob, got %s\n", buffer);
 823
 824     sz = sizeof(buffer);
 825     r = MsiRecordGetString(hrec, 3, buffer, &sz);
 826     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 827     ok(!lstrcmp(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
 828
 829     /* update the view, non-primary key */
 830     r = MsiRecordSetString(hrec, 3, "3141592");
 831     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 832
 833     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 834     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 835
 836     /* do it again */
 837     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 838     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 839
 840     /* update the view, primary key */
 841     r = MsiRecordSetInteger(hrec, 1, 5);
 842     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 843
 844     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 845     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 846
 847     r = MsiCloseHandle(hrec);
 848     ok(r == ERROR_SUCCESS, "failed to close record\n");
 849
 850     r = MsiViewClose(hview);
 851     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 852     r = MsiCloseHandle(hview);
 853     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 854
 855     query = "SELECT * FROM `phone`";
 856     r = MsiDatabaseOpenView(hdb, query, &hview);
 857     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 858
 859     r = MsiViewExecute(hview, 0);
 860     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 861
 862     r = MsiViewFetch(hview, &hrec);
 863     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 864
 865     r = MsiRecordGetInteger(hrec, 1);
 866     ok(r == 1, "Expected 1, got %d\n", r);
 867
 868     sz = sizeof(buffer);
 869     r = MsiRecordGetString(hrec, 2, buffer, &sz);
 870     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 871     ok(!lstrcmp(buffer, "bob"), "Expected bob, got %s\n", buffer);
 872
 873     sz = sizeof(buffer);
 874     r = MsiRecordGetString(hrec, 3, buffer, &sz);
 875     ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
 876     ok(!lstrcmp(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
 877
 878     r = MsiCloseHandle(hrec);
 879     ok(r == ERROR_SUCCESS, "failed to close record\n");
 880
 881     /* use a record that doesn't come from a view fetch */
 882     hrec = MsiCreateRecord(3);
 883     ok(hrec != 0, "MsiCreateRecord failed\n");
 884
 885     r = MsiRecordSetInteger(hrec, 1, 3);
 886     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 887     r = MsiRecordSetString(hrec, 2, "jane");
 888     ok(r == ERROR_SUCCESS, "failed to set string\n");
 889     r = MsiRecordSetString(hrec, 3, "112358");
 890     ok(r == ERROR_SUCCESS, "failed to set string\n");
 891
 892     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 893     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
 894
 895     r = MsiCloseHandle(hrec);
 896     ok(r == ERROR_SUCCESS, "failed to close record\n");
 897
 898     /* use a record that doesn't come from a view fetch, primary key matches */
 899     hrec = MsiCreateRecord(3);
 900     ok(hrec != 0, "MsiCreateRecord failed\n");
 901
 902     r = MsiRecordSetInteger(hrec, 1, 1);
 903     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 904     r = MsiRecordSetString(hrec, 2, "jane");
 905     ok(r == ERROR_SUCCESS, "failed to set string\n");
 906     r = MsiRecordSetString(hrec, 3, "112358");
 907     ok(r == ERROR_SUCCESS, "failed to set string\n");
 908
 909     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 910     todo_wine
 911     {
 912         ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 913     }
 914
 915     r = MsiCloseHandle(hrec);
 916     ok(r == ERROR_SUCCESS, "failed to close record\n");
 917
 918     hrec = MsiCreateRecord(3);
 919
 920     r = MsiRecordSetInteger(hrec, 1, 2);
 921     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 922     r = MsiRecordSetString(hrec, 2, "nick");
 923     ok(r == ERROR_SUCCESS, "failed to set string\n");
 924     r = MsiRecordSetString(hrec, 3, "141421");
 925     ok(r == ERROR_SUCCESS, "failed to set string\n");
 926
 927     r = MsiViewExecute(hview, 0);
 928     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 929     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 930     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 931
 932     r = MsiViewClose(hview);
 933     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 934     r = MsiCloseHandle(hview);
 935     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 936
 937     query = "SELECT * FROM `phone` WHERE `id` = 1";
 938     r = MsiDatabaseOpenView(hdb, query, &hview);
 939     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 940     r = MsiViewExecute(hview, 0);
 941     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 942     r = MsiViewFetch(hview, &hrec);
 943     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 944
 945     /* change the id to match the second row */
 946     r = MsiRecordSetInteger(hrec, 1, 2);
 947     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 948     r = MsiRecordSetString(hrec, 2, "jerry");
 949     ok(r == ERROR_SUCCESS, "failed to set string\n");
 950
 951     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 952     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 953
 954     r = MsiCloseHandle(hrec);
 955     ok(r == ERROR_SUCCESS, "failed to close record\n");
 956     r = MsiViewClose(hview);
 957     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 958     r = MsiCloseHandle(hview);
 959     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 960
 961     /* broader search */
 962     query = "SELECT * FROM `phone` ORDER BY `id`";
 963     r = MsiDatabaseOpenView(hdb, query, &hview);
 964     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 965     r = MsiViewExecute(hview, 0);
 966     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 967     r = MsiViewFetch(hview, &hrec);
 968     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 969
 970     /* change the id to match the second row */
 971     r = MsiRecordSetInteger(hrec, 1, 2);
 972     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 973     r = MsiRecordSetString(hrec, 2, "jerry");
 974     ok(r == ERROR_SUCCESS, "failed to set string\n");
 975
 976     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
 977     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 978
 979     r = MsiCloseHandle(hrec);
 980     ok(r == ERROR_SUCCESS, "failed to close record\n");
 981     r = MsiViewClose(hview);
 982     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 983     r = MsiCloseHandle(hview);
 984     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 985
 986     r = MsiCloseHandle( hdb );
 987     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
 988 }
 989
 990 static MSIHANDLE create_db(void)
 991 {
 992     MSIHANDLE hdb = 0;
 993     UINT res;
 994
 995     DeleteFile(msifile);
 996
 997     /* create an empty database */
 998     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
 999     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
1000     if( res != ERROR_SUCCESS )
1001         return hdb;
1002
1003     res = MsiDatabaseCommit( hdb );
1004     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
1005
1006     return hdb;
1007 }
1008
1009 static void test_getcolinfo(void)
1010 {
1011     MSIHANDLE hdb, hview = 0, rec = 0;
1012     UINT r;
1013     DWORD sz;
1014     char buffer[0x20];
1015
1016     /* create an empty db */
1017     hdb = create_db();
1018     ok( hdb, "failed to create db\n");
1019
1020     /* tables should be present */
1021     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
1022     ok( r == ERROR_SUCCESS, "failed to open query\n");
1023
1024     r = MsiViewExecute(hview, 0);
1025     ok( r == ERROR_SUCCESS, "failed to execute query\n");
1026
1027     /* check that NAMES works */
1028     rec = 0;
1029     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
1030     ok( r == ERROR_SUCCESS, "failed to get names\n");
1031     sz = sizeof buffer;
1032     r = MsiRecordGetString(rec, 1, buffer, &sz );
1033     ok( r == ERROR_SUCCESS, "failed to get string\n");
1034     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
1035     r = MsiCloseHandle( rec );
1036     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1037
1038     /* check that TYPES works */
1039     rec = 0;
1040     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
1041     ok( r == ERROR_SUCCESS, "failed to get names\n");
1042     sz = sizeof buffer;
1043     r = MsiRecordGetString(rec, 1, buffer, &sz );
1044     ok( r == ERROR_SUCCESS, "failed to get string\n");
1045     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
1046     r = MsiCloseHandle( rec );
1047     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
1048
1049     /* check that invalid values fail */
1050     rec = 0;
1051     r = MsiViewGetColumnInfo( hview, 100, &rec );
1052     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1053     ok( rec == 0, "returned a record\n");
1054
1055     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
1056     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
1057
1058     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
1059     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
1060
1061     r = MsiViewClose(hview);
1062     ok( r == ERROR_SUCCESS, "failed to close view\n");
1063     r = MsiCloseHandle(hview);
1064     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
1065     r = MsiCloseHandle(hdb);
1066     ok( r == ERROR_SUCCESS, "failed to close database\n");
1067 }
1068
1069 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
1070 {
1071     MSIHANDLE hview = 0, rec = 0;
1072     UINT r;
1073
1074     r = MsiDatabaseOpenView(hdb, query, &hview);
1075     if( r != ERROR_SUCCESS )
1076         return r;
1077
1078     r = MsiViewExecute(hview, 0);
1079     if( r == ERROR_SUCCESS )
1080     {
1081         MsiViewGetColumnInfo( hview, type, &rec );
1082         MsiViewClose(hview);
1083     }
1084     MsiCloseHandle(hview);
1085     return rec;
1086 }
1087
1088 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
1089 {
1090     MSIHANDLE hview = 0, rec = 0;
1091     UINT r, type = 0;
1092     char query[0x100];
1093
1094     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
1095
1096     r = MsiDatabaseOpenView(hdb, query, &hview);
1097     if( r != ERROR_SUCCESS )
1098         return r;
1099
1100     r = MsiViewExecute(hview, 0);
1101     if( r == ERROR_SUCCESS )
1102     {
1103         while (1)
1104         {
1105             r = MsiViewFetch( hview, &rec );
1106             if( r != ERROR_SUCCESS)
1107                 break;
1108             r = MsiRecordGetInteger( rec, 2 );
1109             if (r == field)
1110                 type = MsiRecordGetInteger( rec, 4 );
1111             MsiCloseHandle( rec );
1112         }
1113
1114         MsiViewClose(hview);
1115     }
1116     MsiCloseHandle(hview);
1117     return type;
1118 }
1119
1120 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
1121 {
1122     CHAR buffer[0x20];
1123     UINT r;
1124     DWORD sz;
1125
1126     sz = sizeof buffer;
1127     r = MsiRecordGetString( rec, field, buffer, &sz );
1128     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
1129 }
1130
1131 static void test_viewgetcolumninfo(void)
1132 {
1133     MSIHANDLE hdb = 0, rec;
1134     UINT r;
1135
1136     hdb = create_db();
1137     ok( hdb, "failed to create db\n");
1138
1139     r = run_query( hdb, 0,
1140             "CREATE TABLE `Properties` "
1141             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1142     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1143
1144     /* check the column types */
1145     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
1146     ok( rec, "failed to get column info record\n" );
1147
1148     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1149     ok( check_record( rec, 2, "S1"), "wrong record type\n");
1150
1151     MsiCloseHandle( rec );
1152
1153     /* check the type in _Columns */
1154     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
1155     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
1156
1157     /* now try the names */
1158     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
1159     ok( rec, "failed to get column info record\n" );
1160
1161     ok( check_record( rec, 1, "Property"), "wrong record type\n");
1162     ok( check_record( rec, 2, "Value"), "wrong record type\n");
1163
1164     MsiCloseHandle( rec );
1165
1166     r = run_query( hdb, 0,
1167             "CREATE TABLE `Binary` "
1168             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
1169     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1170
1171     /* check the column types */
1172     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
1173     ok( rec, "failed to get column info record\n" );
1174
1175     ok( check_record( rec, 1, "S255"), "wrong record type\n");
1176     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1177
1178     MsiCloseHandle( rec );
1179
1180     /* check the type in _Columns */
1181     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1182     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1183
1184     /* now try the names */
1185     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1186     ok( rec, "failed to get column info record\n" );
1187
1188     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1189     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1190     MsiCloseHandle( rec );
1191
1192     r = run_query( hdb, 0,
1193             "CREATE TABLE `UIText` "
1194             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1195     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1196
1197     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1198     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1199
1200     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1201     ok( rec, "failed to get column info record\n" );
1202     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1203     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1204     MsiCloseHandle( rec );
1205
1206     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1207     ok( rec, "failed to get column info record\n" );
1208     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1209     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1210     MsiCloseHandle( rec );
1211
1212     MsiCloseHandle( hdb );
1213 }
1214
1215 static void test_msiexport(void)
1216 {
1217     MSIHANDLE hdb = 0, hview = 0;
1218     UINT r;
1219     const char *query;
1220     char path[MAX_PATH];
1221     const char file[] = "phone.txt";
1222     HANDLE handle;
1223     char buffer[0x100];
1224     DWORD length;
1225     const char expected[] =
1226         "id\tname\tnumber\r\n"
1227         "I2\tS32\tS32\r\n"
1228         "phone\tid\r\n"
1229         "1\tAbe\t8675309\r\n";
1230
1231     DeleteFile(msifile);
1232
1233     /* just MsiOpenDatabase should not create a file */
1234     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1235     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1236
1237     /* create a table */
1238     query = "CREATE TABLE `phone` ( "
1239             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1240             "PRIMARY KEY `id`)";
1241     r = MsiDatabaseOpenView(hdb, query, &hview);
1242     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1243     r = MsiViewExecute(hview, 0);
1244     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1245     r = MsiViewClose(hview);
1246     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1247     r = MsiCloseHandle(hview);
1248     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1249
1250     /* insert a value into it */
1251     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1252         "VALUES('1', 'Abe', '8675309')";
1253     r = MsiDatabaseOpenView(hdb, query, &hview);
1254     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1255     r = MsiViewExecute(hview, 0);
1256     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1257     r = MsiViewClose(hview);
1258     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1259     r = MsiCloseHandle(hview);
1260     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1261
1262     GetCurrentDirectory(MAX_PATH, path);
1263
1264     r = MsiDatabaseExport(hdb, "phone", path, file);
1265     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1266
1267     MsiCloseHandle(hdb);
1268
1269     lstrcat(path, "\\");
1270     lstrcat(path, file);
1271
1272     /* check the data that was written */
1273     length = 0;
1274     memset(buffer, 0, sizeof buffer);
1275     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1276     if (handle != INVALID_HANDLE_VALUE)
1277     {
1278         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1279         CloseHandle(handle);
1280         DeleteFile(path);
1281     }
1282     else
1283         ok(0, "failed to open file %s\n", path);
1284
1285     ok( length == strlen(expected), "length of data wrong\n");
1286     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
1287     DeleteFile(msifile);
1288 }
1289
1290 static void test_longstrings(void)
1291 {
1292     const char insert_query[] =
1293         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1294     char *str;
1295     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1296     DWORD len;
1297     UINT r;
1298     const DWORD STRING_LENGTH = 0x10005;
1299
1300     DeleteFile(msifile);
1301     /* just MsiOpenDatabase should not create a file */
1302     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1303     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1304
1305     /* create a table */
1306     r = try_query( hdb,
1307         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1308     ok(r == ERROR_SUCCESS, "query failed\n");
1309
1310     /* try a insert a very long string */
1311     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1312     len = strchr(insert_query, 'Z') - insert_query;
1313     strcpy(str, insert_query);
1314     memset(str+len, 'Z', STRING_LENGTH);
1315     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1316     r = try_query( hdb, str );
1317     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1318
1319     HeapFree(GetProcessHeap(), 0, str);
1320
1321     MsiDatabaseCommit(hdb);
1322     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1323     MsiCloseHandle(hdb);
1324
1325     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
1326     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1327
1328     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
1329     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1330
1331     r = MsiViewExecute(hview, 0);
1332     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1333
1334     r = MsiViewFetch(hview, &hrec);
1335     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1336
1337     MsiCloseHandle(hview);
1338
1339     r = MsiRecordGetString(hrec, 2, NULL, &len);
1340     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1341     ok(len == STRING_LENGTH, "string length wrong\n");
1342
1343     MsiCloseHandle(hrec);
1344     MsiCloseHandle(hdb);
1345     DeleteFile(msifile);
1346 }
1347
1348 static void create_file(const CHAR *name)
1349 {
1350     HANDLE file;
1351     DWORD written;
1352
1353     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1354     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
1355     WriteFile(file, name, strlen(name), &written, NULL);
1356     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1357     CloseHandle(file);
1358 }
1359
1360 static void test_streamtable(void)
1361 {
1362     MSIHANDLE hdb = 0, rec, view;
1363     char file[MAX_PATH];
1364     char buf[MAX_PATH];
1365     DWORD size;
1366     UINT r;
1367
1368     hdb = create_db();
1369     ok( hdb, "failed to create db\n");
1370
1371     r = run_query( hdb, 0,
1372             "CREATE TABLE `Properties` "
1373             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1374     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1375
1376     r = run_query( hdb, 0,
1377             "INSERT INTO `Properties` "
1378             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1379     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1380
1381     r = MsiDatabaseCommit( hdb );
1382     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1383
1384     MsiCloseHandle( hdb );
1385
1386     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
1387     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1388
1389     /* check the column types */
1390     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1391     ok( rec, "failed to get column info record\n" );
1392
1393     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1394     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1395
1396     MsiCloseHandle( rec );
1397
1398     /* now try the names */
1399     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1400     ok( rec, "failed to get column info record\n" );
1401
1402     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1403     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1404
1405     MsiCloseHandle( rec );
1406
1407     /* insert a file into the _Streams table */
1408     create_file( "test.txt" );
1409
1410     rec = MsiCreateRecord( 2 );
1411     MsiRecordSetString( rec, 1, "data" );
1412
1413     r = MsiRecordSetStream( rec, 2, "test.txt" );
1414     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1415
1416     DeleteFile("test.txt");
1417
1418     r = MsiDatabaseOpenView( hdb,
1419             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1420     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1421
1422     r = MsiViewExecute( view, rec );
1423     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1424
1425     MsiCloseHandle( rec );
1426     MsiCloseHandle( view );
1427
1428     r = MsiDatabaseOpenView( hdb,
1429             "SELECT `Name`, `Data` FROM `_Streams`", &view );
1430     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1431
1432     r = MsiViewExecute( view, 0 );
1433     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1434
1435     r = MsiViewFetch( view, &rec );
1436     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1437
1438     size = MAX_PATH;
1439     r = MsiRecordGetString( rec, 1, file, &size );
1440     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1441     ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1442
1443     size = MAX_PATH;
1444     memset(buf, 0, MAX_PATH);
1445     r = MsiRecordReadStream( rec, 2, buf, &size );
1446     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1447     ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1448
1449     MsiCloseHandle( rec );
1450
1451     r = MsiViewFetch( view, &rec );
1452     ok( r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1453
1454     MsiCloseHandle( view );
1455     MsiCloseHandle( hdb );
1456     DeleteFile(msifile);
1457 }
1458
1459 static void test_where(void)
1460 {
1461     MSIHANDLE hdb = 0, rec, view;
1462     LPCSTR query;
1463     UINT r;
1464     DWORD size;
1465     CHAR buf[MAX_PATH];
1466     UINT count;
1467
1468     hdb = create_db();
1469     ok( hdb, "failed to create db\n");
1470
1471     r = run_query( hdb, 0,
1472             "CREATE TABLE `Media` ("
1473             "`DiskId` SHORT NOT NULL, "
1474             "`LastSequence` LONG, "
1475             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1476             "`Cabinet` CHAR(255), "
1477             "`VolumeLabel` CHAR(32), "
1478             "`Source` CHAR(72) "
1479             "PRIMARY KEY `DiskId`)" );
1480     ok( r == S_OK, "cannot create Media table: %d\n", r );
1481
1482     r = run_query( hdb, 0, "INSERT INTO `Media` "
1483             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1484             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1485     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1486
1487     r = run_query( hdb, 0, "INSERT INTO `Media` "
1488             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1489             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1490     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1491
1492     r = run_query( hdb, 0, "INSERT INTO `Media` "
1493             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1494             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1495     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1496
1497     query = "SELECT * FROM `Media`";
1498     r = do_query(hdb, query, &rec);
1499     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1500     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1501     MsiCloseHandle( rec );
1502
1503     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1504     r = do_query(hdb, query, &rec);
1505     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1506     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1507
1508     r = MsiRecordGetInteger(rec, 1);
1509     ok( 2 == r, "field wrong\n");
1510     r = MsiRecordGetInteger(rec, 2);
1511     ok( 1 == r, "field wrong\n");
1512     MsiCloseHandle( rec );
1513
1514     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
1515     r = MsiDatabaseOpenView(hdb, query, &view);
1516     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1517
1518     r = MsiViewExecute(view, 0);
1519     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1520
1521     r = MsiViewFetch(view, &rec);
1522     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1523
1524     count = MsiRecordGetFieldCount( rec );
1525     ok( count == 1, "Expected 1 record fields, got %d\n", count );
1526
1527     size = MAX_PATH;
1528     r = MsiRecordGetString( rec, 1, buf, &size );
1529     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1530     ok( !lstrcmp( buf, "2" ),
1531         "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
1532     MsiCloseHandle( rec );
1533
1534     r = MsiViewFetch(view, &rec);
1535     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1536
1537     size = MAX_PATH;
1538     r = MsiRecordGetString( rec, 1, buf, &size );
1539     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1540     ok( !lstrcmp( buf, "3" ),
1541         "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
1542     MsiCloseHandle( rec );
1543
1544     r = MsiViewFetch(view, &rec);
1545     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1546
1547     MsiViewClose(view);
1548     MsiCloseHandle(view);
1549
1550     MsiCloseHandle( rec );
1551
1552     rec = 0;
1553     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
1554     r = do_query(hdb, query, &rec);
1555     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
1556     MsiCloseHandle( rec );
1557
1558     rec = MsiCreateRecord(1);
1559     MsiRecordSetString(rec, 1, "");
1560
1561     query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
1562     r = MsiDatabaseOpenView(hdb, query, &view);
1563     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1564     r = MsiViewExecute(view, rec);
1565     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1566
1567     MsiCloseHandle(rec);
1568
1569     r = MsiViewFetch(view, &rec);
1570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1571
1572     MsiCloseHandle(rec);
1573     MsiViewClose(view);
1574     MsiCloseHandle(view);
1575
1576     MsiCloseHandle( hdb );
1577     DeleteFile(msifile);
1578 }
1579
1580 static CHAR CURR_DIR[MAX_PATH];
1581
1582 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1583                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1584                                 "TestTable\tFirstPrimaryColumn\n"
1585                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1586
1587 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
1588                                   "s255\ts255\n"
1589                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
1590                                   "papaya\tleaf\n"
1591                                   "papaya\tflower\n";
1592
1593 static void write_file(const CHAR *filename, const char *data, int data_size)
1594 {
1595     DWORD size;
1596
1597     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1598                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1599
1600     WriteFile(hf, data, data_size, &size, NULL);
1601     CloseHandle(hf);
1602 }
1603
1604 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1605 {
1606     UINT r;
1607
1608     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1609     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1610     DeleteFileA("temp_file");
1611
1612     return r;
1613 }
1614
1615 static void test_msiimport(void)
1616 {
1617     MSIHANDLE hdb, view, rec;
1618     LPCSTR query;
1619     UINT r, count;
1620     signed int i;
1621
1622     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1623
1624     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1625     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1626
1627     r = add_table_to_db(hdb, test_data);
1628     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1629
1630     r = add_table_to_db(hdb, two_primary);
1631     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1632
1633     query = "SELECT * FROM `TestTable`";
1634     r = MsiDatabaseOpenView(hdb, query, &view);
1635     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1636
1637     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1638     count = MsiRecordGetFieldCount(rec);
1639     ok(count == 9, "Expected 9, got %d\n", count);
1640     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1641     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1642     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1643     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1644     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1645     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1646     ok(check_record(rec, 7, "String"), "Expected String\n");
1647     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1648     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1649     MsiCloseHandle(rec);
1650
1651     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1652     count = MsiRecordGetFieldCount(rec);
1653     ok(count == 9, "Expected 9, got %d\n", count);
1654     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1655     ok(check_record(rec, 2, "i2"), "Expected i2\n");
1656     ok(check_record(rec, 3, "i2"), "Expected i2\n");
1657     ok(check_record(rec, 4, "I2"), "Expected I2\n");
1658     ok(check_record(rec, 5, "i4"), "Expected i4\n");
1659     ok(check_record(rec, 6, "I4"), "Expected I4\n");
1660     ok(check_record(rec, 7, "S255"), "Expected S255\n");
1661     ok(check_record(rec, 8, "S0"), "Expected S0\n");
1662     ok(check_record(rec, 9, "s0"), "Expected s0\n");
1663     MsiCloseHandle(rec);
1664
1665     query = "SELECT * FROM `TestTable`";
1666     r = do_query(hdb, query, &rec);
1667     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1668     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1669     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1670     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1671     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1672
1673     i = MsiRecordGetInteger(rec, 2);
1674     ok(i == 5, "Expected 5, got %d\n", i);
1675
1676     i = MsiRecordGetInteger(rec, 3);
1677     ok(i == 2, "Expected 2, got %d\n", i);
1678
1679     i = MsiRecordGetInteger(rec, 4);
1680     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
1681
1682     i = MsiRecordGetInteger(rec, 5);
1683     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1684
1685     i = MsiRecordGetInteger(rec, 6);
1686     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1687
1688     MsiCloseHandle(rec);
1689     MsiCloseHandle(view);
1690
1691     query = "SELECT * FROM `TwoPrimary`";
1692     r = MsiDatabaseOpenView(hdb, query, &view);
1693     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1694
1695     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1696     count = MsiRecordGetFieldCount(rec);
1697     ok(count == 2, "Expected 2, got %d\n", count);
1698     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
1699     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
1700
1701     MsiCloseHandle(rec);
1702
1703     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1704     count = MsiRecordGetFieldCount(rec);
1705     ok(count == 2, "Expected 2, got %d\n", count);
1706     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1707     ok(check_record(rec, 2, "s255"), "Expected s255\n");
1708     MsiCloseHandle(rec);
1709
1710     r = MsiViewExecute(view, 0);
1711     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1712
1713     r = MsiViewFetch(view, &rec);
1714     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1715
1716     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1717     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
1718
1719     MsiCloseHandle(rec);
1720
1721     r = MsiViewFetch(view, &rec);
1722     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1723
1724     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1725     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
1726
1727     MsiCloseHandle(rec);
1728
1729     r = MsiViewFetch(view, &rec);
1730     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1731
1732     r = MsiViewClose(view);
1733     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1734
1735     MsiCloseHandle(view);
1736     MsiCloseHandle(hdb);
1737     DeleteFileA(msifile);
1738 }
1739
1740 static void test_markers(void)
1741 {
1742     MSIHANDLE hdb, rec;
1743     LPCSTR query;
1744     UINT r;
1745
1746     hdb = create_db();
1747     ok( hdb, "failed to create db\n");
1748
1749     rec = MsiCreateRecord(3);
1750     MsiRecordSetString(rec, 1, "Table");
1751     MsiRecordSetString(rec, 2, "Apples");
1752     MsiRecordSetString(rec, 3, "Oranges");
1753
1754     /* try a legit create */
1755     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1756     r = run_query(hdb, 0, query);
1757     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1758     MsiCloseHandle(rec);
1759
1760     /* try table name as marker */
1761     rec = MsiCreateRecord(1);
1762     MsiRecordSetString(rec, 1, "Fable");
1763     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1764     r = run_query(hdb, rec, query);
1765     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1766
1767     /* verify that we just created a table called '?', not 'Fable' */
1768     r = try_query(hdb, "SELECT * from `Fable`");
1769     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1770
1771     r = try_query(hdb, "SELECT * from `?`");
1772     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1773
1774     /* try table name as marker without backticks */
1775     MsiRecordSetString(rec, 1, "Mable");
1776     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1777     r = run_query(hdb, rec, query);
1778     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1779
1780     /* try one column name as marker */
1781     MsiRecordSetString(rec, 1, "One");
1782     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1783     r = run_query(hdb, rec, query);
1784     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1785     MsiCloseHandle(rec);
1786
1787     /* try column names as markers */
1788     rec = MsiCreateRecord(2);
1789     MsiRecordSetString(rec, 1, "One");
1790     MsiRecordSetString(rec, 2, "Two");
1791     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1792     r = run_query(hdb, rec, query);
1793     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1794     MsiCloseHandle(rec);
1795
1796     /* try names with backticks */
1797     rec = MsiCreateRecord(3);
1798     MsiRecordSetString(rec, 1, "One");
1799     MsiRecordSetString(rec, 2, "Two");
1800     MsiRecordSetString(rec, 3, "One");
1801     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1802     r = run_query(hdb, rec, query);
1803     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1804
1805     /* try names with backticks, minus definitions */
1806     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1807     r = run_query(hdb, rec, query);
1808     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1809
1810     /* try names without backticks */
1811     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1812     r = run_query(hdb, rec, query);
1813     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1814     MsiCloseHandle(rec);
1815
1816     /* try one long marker */
1817     rec = MsiCreateRecord(1);
1818     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1819     query = "CREATE TABLE `Mable` ( ? )";
1820     r = run_query(hdb, rec, query);
1821     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1822     MsiCloseHandle(rec);
1823
1824     /* try all names as markers */
1825     rec = MsiCreateRecord(4);
1826     MsiRecordSetString(rec, 1, "Mable");
1827     MsiRecordSetString(rec, 2, "One");
1828     MsiRecordSetString(rec, 3, "Two");
1829     MsiRecordSetString(rec, 4, "One");
1830     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1831     r = run_query(hdb, rec, query);
1832     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1833     MsiCloseHandle(rec);
1834
1835     /* try a legit insert */
1836     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1837     r = run_query(hdb, 0, query);
1838     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1839
1840     r = try_query(hdb, "SELECT * from `Table`");
1841     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1842
1843     /* try values as markers */
1844     rec = MsiCreateRecord(2);
1845     MsiRecordSetInteger(rec, 1, 4);
1846     MsiRecordSetString(rec, 2, "hi");
1847     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1848     r = run_query(hdb, rec, query);
1849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1850     MsiCloseHandle(rec);
1851
1852     /* try column names and values as markers */
1853     rec = MsiCreateRecord(4);
1854     MsiRecordSetString(rec, 1, "One");
1855     MsiRecordSetString(rec, 2, "Two");
1856     MsiRecordSetInteger(rec, 3, 5);
1857     MsiRecordSetString(rec, 4, "hi");
1858     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1859     r = run_query(hdb, rec, query);
1860     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1861     MsiCloseHandle(rec);
1862
1863     /* try column names as markers */
1864     rec = MsiCreateRecord(2);
1865     MsiRecordSetString(rec, 1, "One");
1866     MsiRecordSetString(rec, 2, "Two");
1867     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1868     r = run_query(hdb, rec, query);
1869     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1870     MsiCloseHandle(rec);
1871
1872     /* try table name as a marker */
1873     rec = MsiCreateRecord(1);
1874     MsiRecordSetString(rec, 1, "Table");
1875     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1876     r = run_query(hdb, rec, query);
1877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1878     MsiCloseHandle(rec);
1879
1880     /* try table name and values as markers */
1881     rec = MsiCreateRecord(3);
1882     MsiRecordSetString(rec, 1, "Table");
1883     MsiRecordSetInteger(rec, 2, 10);
1884     MsiRecordSetString(rec, 3, "haha");
1885     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1886     r = run_query(hdb, rec, query);
1887     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1888     MsiCloseHandle(rec);
1889
1890     /* try all markers */
1891     rec = MsiCreateRecord(5);
1892     MsiRecordSetString(rec, 1, "Table");
1893     MsiRecordSetString(rec, 1, "One");
1894     MsiRecordSetString(rec, 1, "Two");
1895     MsiRecordSetInteger(rec, 2, 10);
1896     MsiRecordSetString(rec, 3, "haha");
1897     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1898     r = run_query(hdb, rec, query);
1899     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1900     MsiCloseHandle(rec);
1901
1902     /* insert an integer as a string */
1903     rec = MsiCreateRecord(2);
1904     MsiRecordSetString(rec, 1, "11");
1905     MsiRecordSetString(rec, 2, "hi");
1906     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1907     r = run_query(hdb, rec, query);
1908     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1909     MsiCloseHandle(rec);
1910
1911     /* leave off the '' for the string */
1912     rec = MsiCreateRecord(2);
1913     MsiRecordSetInteger(rec, 1, 12);
1914     MsiRecordSetString(rec, 2, "hi");
1915     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
1916     r = run_query(hdb, rec, query);
1917     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1918     MsiCloseHandle(rec);
1919
1920     MsiCloseHandle(hdb);
1921     DeleteFileA(msifile);
1922 }
1923
1924 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
1925 static void test_handle_limit(void)
1926 {
1927     int i;
1928     MSIHANDLE hdb;
1929     MSIHANDLE hviews[MY_NVIEWS];
1930     UINT r;
1931
1932     /* create an empty db */
1933     hdb = create_db();
1934     ok( hdb, "failed to create db\n");
1935
1936     memset(hviews, 0, sizeof(hviews));
1937
1938     for (i=0; i<MY_NVIEWS; i++) {
1939         static char szQueryBuf[256] = "SELECT * from `_Tables`";
1940         hviews[i] = 0xdeadbeeb;
1941         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
1942         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
1943             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
1944             break;
1945     }
1946
1947     ok( i == MY_NVIEWS, "problem opening views\n");
1948
1949     for (i=0; i<MY_NVIEWS; i++) {
1950         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
1951             r = MsiCloseHandle(hviews[i]);
1952             if (r != ERROR_SUCCESS)
1953                 break;
1954         }
1955     }
1956
1957     ok( i == MY_NVIEWS, "problem closing views\n");
1958
1959     r = MsiCloseHandle(hdb);
1960     ok( r == ERROR_SUCCESS, "failed to close database\n");
1961 }
1962
1963 static void generate_transform(void)
1964 {
1965     MSIHANDLE hdb1, hdb2, hrec;
1966     LPCSTR query;
1967     UINT r;
1968
1969     /* start with two identical databases */
1970     CopyFile(msifile2, msifile, FALSE);
1971
1972     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb1 );
1973     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1974
1975     r = MsiDatabaseCommit( hdb1 );
1976     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1977
1978     r = MsiOpenDatabase(msifile2, MSIDBOPEN_READONLY, &hdb2 );
1979     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1980
1981     /* the transform between two identical database should be empty */
1982     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1983     todo_wine {
1984     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
1985     }
1986
1987     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
1988     r = run_query(hdb1, 0, query);
1989     ok(r == ERROR_SUCCESS, "failed to add table\n");
1990
1991     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
1992     r = run_query(hdb1, 0, query);
1993     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
1994
1995     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
1996     r = run_query(hdb1, 0, query);
1997     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
1998
1999     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2000     r = run_query(hdb1, 0, query);
2001     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2002
2003     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2004     r = run_query(hdb1, 0, query);
2005     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2006
2007     hrec = MsiCreateRecord(2);
2008     r = MsiRecordSetInteger(hrec, 1, 1);
2009     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2010
2011     write_file("testdata.bin", "naengmyon", 9);
2012     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2013     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2014
2015     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2016     r = run_query(hdb1, hrec, query);
2017     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2018
2019     MsiCloseHandle(hrec);
2020
2021     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2022     r = run_query(hdb1, 0, query);
2023     ok(r == ERROR_SUCCESS, "failed to add column\n");
2024
2025     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2026     r = run_query(hdb1, 0, query);
2027     ok(r == ERROR_SUCCESS, "failed to add column\n");
2028
2029     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2030     r = run_query(hdb1, 0, query);
2031     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2032
2033     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2034             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2035     r = run_query(hdb1, 0, query);
2036     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2037
2038     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2039     r = run_query(hdb1, 0, query);
2040     ok(r == ERROR_SUCCESS, "failed to add property\n");
2041
2042     /* database needs to be committed */
2043     MsiDatabaseCommit(hdb1);
2044
2045     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
2046     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2047
2048     MsiCloseHandle( hdb1 );
2049     MsiCloseHandle( hdb2 );
2050
2051     DeleteFile("testdata.bin");
2052 }
2053
2054 /* data for generating a transform */
2055
2056 /* tables transform names - encoded as they would be in an msi database file */
2057 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2058 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2059 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2060 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2061 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2062 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2063 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2064 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2065 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2066
2067 /* data in each table */
2068 static const WCHAR data1[] = { /* AAR */
2069     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2070     0x0201, 0x0009, 0x8002,
2071 };
2072 static const WCHAR data2[] = { /* _Columns */
2073     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2074     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2075     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2076     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2077     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2078     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2079 };
2080 static const WCHAR data3[] = { /* _Tables */
2081     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2082     0x0101, 0x000a,
2083 };
2084 static const char data4[] = /* _StringData */
2085     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2086 static const WCHAR data5[] = { /* _StringPool */
2087 /*  len, refs */
2088     0,   0,    /* string 0 ''    */
2089     3,   2,    /* string 1 'MOO' */
2090     3,   1,    /* string 2 'COW' */
2091     3,   1,    /* string 3 'PIG' */
2092     1,   1,    /* string 4 'c'   */
2093     3,   3,    /* string 5 'AAR' */
2094     3,   1,    /* string 6 'CAR' */
2095     3,   1,    /* string 7 'BAR' */
2096     2,   1,    /* string 8 'vw'  */
2097     3,   1,    /* string 9 'bmw' */
2098     8,   4,    /* string 10 'Property' */
2099     5,   1,    /* string 11 'Value' */
2100     4,   1,    /* string 12 'prop' */
2101     3,   1,    /* string 13 'val' */
2102 };
2103 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2104 static const WCHAR data6[] = { /* MOO */
2105     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2106     0x0000, 0x8003,         /* delete row */
2107 };
2108
2109 static const WCHAR data7[] = { /* BINARY */
2110     0x0201, 0x8001, 0x0001,
2111 };
2112
2113 static const char data8[] =  /* stream data for the BINARY table */
2114     "naengmyon";
2115
2116 static const WCHAR data9[] = { /* Property */
2117     0x0201, 0x000c, 0x000d,
2118 };
2119
2120 static const struct {
2121     LPCWSTR name;
2122     const void *data;
2123     DWORD size;
2124 } table_transform_data[] =
2125 {
2126     { name1, data1, sizeof data1 },
2127     { name2, data2, sizeof data2 },
2128     { name3, data3, sizeof data3 },
2129     { name4, data4, sizeof data4 - 1 },
2130     { name5, data5, sizeof data5 },
2131     { name6, data6, sizeof data6 },
2132     { name7, data7, sizeof data7 },
2133     { name8, data8, sizeof data8 - 1 },
2134     { name9, data9, sizeof data9 },
2135 };
2136
2137 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2138
2139 static void generate_transform_manual(void)
2140 {
2141     IStorage *stg = NULL;
2142     IStream *stm;
2143     WCHAR name[0x20];
2144     HRESULT r;
2145     DWORD i, count;
2146     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2147
2148     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
2149
2150     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
2151
2152     r = StgCreateDocfile(name, mode, 0, &stg);
2153     ok(r == S_OK, "failed to create storage\n");
2154     if (!stg)
2155         return;
2156
2157     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
2158     ok(r == S_OK, "failed to set storage type\n");
2159
2160     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
2161     {
2162         r = IStorage_CreateStream( stg, table_transform_data[i].name,
2163                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
2164         if (FAILED(r))
2165         {
2166             ok(0, "failed to create stream %08x\n", r);
2167             continue;
2168         }
2169
2170         r = IStream_Write( stm, table_transform_data[i].data,
2171                           table_transform_data[i].size, &count );
2172         if (FAILED(r) || count != table_transform_data[i].size)
2173             ok(0, "failed to write stream\n");
2174         IStream_Release(stm);
2175     }
2176
2177     IStorage_Release(stg);
2178 }
2179
2180 static UINT set_summary_info(MSIHANDLE hdb)
2181 {
2182     UINT res;
2183     MSIHANDLE suminfo;
2184
2185     /* build summmary info */
2186     res = MsiGetSummaryInformation(hdb, NULL, 7, &suminfo);
2187     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
2188
2189     res = MsiSummaryInfoSetProperty(suminfo,2, VT_LPSTR, 0,NULL,
2190                         "Installation Database");
2191     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2192
2193     res = MsiSummaryInfoSetProperty(suminfo,3, VT_LPSTR, 0,NULL,
2194                         "Installation Database");
2195     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2196
2197     res = MsiSummaryInfoSetProperty(suminfo,4, VT_LPSTR, 0,NULL,
2198                         "Wine Hackers");
2199     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2200
2201     res = MsiSummaryInfoSetProperty(suminfo,7, VT_LPSTR, 0,NULL,
2202                     ";1033");
2203     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2204
2205     res = MsiSummaryInfoSetProperty(suminfo,9, VT_LPSTR, 0,NULL,
2206                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
2207     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2208
2209     res = MsiSummaryInfoSetProperty(suminfo, 14, VT_I4, 100, NULL, NULL);
2210     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2211
2212     res = MsiSummaryInfoSetProperty(suminfo, 15, VT_I4, 0, NULL, NULL);
2213     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2214
2215     res = MsiSummaryInfoPersist(suminfo);
2216     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
2217
2218     res = MsiCloseHandle( suminfo);
2219     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
2220
2221     return res;
2222 }
2223
2224 static MSIHANDLE create_package_db(LPCSTR filename)
2225 {
2226     MSIHANDLE hdb = 0;
2227     UINT res;
2228
2229     DeleteFile(msifile);
2230
2231     /* create an empty database */
2232     res = MsiOpenDatabase(filename, MSIDBOPEN_CREATE, &hdb );
2233     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
2234     if( res != ERROR_SUCCESS )
2235         return hdb;
2236
2237     res = MsiDatabaseCommit( hdb );
2238     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
2239
2240     res = set_summary_info(hdb);
2241
2242     res = run_query( hdb, 0,
2243             "CREATE TABLE `Directory` ( "
2244             "`Directory` CHAR(255) NOT NULL, "
2245             "`Directory_Parent` CHAR(255), "
2246             "`DefaultDir` CHAR(255) NOT NULL "
2247             "PRIMARY KEY `Directory`)" );
2248     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
2249
2250     return hdb;
2251 }
2252
2253 static MSIHANDLE package_from_db(MSIHANDLE hdb)
2254 {
2255     UINT res;
2256     CHAR szPackage[10];
2257     MSIHANDLE hPackage;
2258
2259     sprintf(szPackage,"#%li",hdb);
2260     res = MsiOpenPackage(szPackage,&hPackage);
2261     if (res != ERROR_SUCCESS)
2262         return 0;
2263
2264     res = MsiCloseHandle(hdb);
2265     if (res != ERROR_SUCCESS)
2266         return 0;
2267
2268     return hPackage;
2269 }
2270
2271 static void test_try_transform(void)
2272 {
2273     MSIHANDLE hdb, hview, hrec, hpkg;
2274     LPCSTR query;
2275     UINT r;
2276     DWORD sz;
2277     char buffer[MAX_PATH];
2278
2279     DeleteFile(msifile);
2280     DeleteFile(mstfile);
2281
2282     /* create the database */
2283     hdb = create_package_db(msifile);
2284     ok(hdb, "Failed to create package db\n");
2285
2286     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
2287     r = run_query(hdb, 0, query);
2288     ok(r == ERROR_SUCCESS, "failed to add table\n");
2289
2290     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
2291     r = run_query(hdb, 0, query);
2292     ok(r == ERROR_SUCCESS, "failed to add row\n");
2293
2294     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
2295     r = run_query(hdb, 0, query);
2296     ok(r == ERROR_SUCCESS, "failed to add row\n");
2297
2298     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
2299     r = run_query(hdb, 0, query);
2300     ok(r == ERROR_SUCCESS, "failed to add row\n");
2301
2302     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
2303     r = run_query(hdb, 0, query);
2304     ok(r == ERROR_SUCCESS, "failed to add table\n");
2305
2306     hrec = MsiCreateRecord(2);
2307     r = MsiRecordSetInteger(hrec, 1, 2);
2308     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2309
2310     write_file("testdata.bin", "lamyon", 6);
2311     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2312     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2313
2314     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2315     r = run_query(hdb, hrec, query);
2316     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2317
2318     MsiCloseHandle(hrec);
2319
2320     r = MsiDatabaseCommit( hdb );
2321     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2322
2323     MsiCloseHandle( hdb );
2324     DeleteFileA("testdata.bin");
2325
2326     /*
2327      * Both these generate an equivalent transform,
2328      *  but the first doesn't work in Wine yet
2329      *  because MsiDatabaseGenerateTransform is unimplemented.
2330      */
2331     if (0)
2332         generate_transform();
2333     else
2334         generate_transform_manual();
2335
2336     r = MsiOpenDatabase(msifile, MSIDBOPEN_DIRECT, &hdb );
2337     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2338
2339     r = MsiDatabaseApplyTransform( hdb, mstfile, 0 );
2340     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2341
2342     MsiDatabaseCommit( hdb );
2343
2344     /* check new values */
2345     hrec = 0;
2346     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
2347     r = do_query(hdb, query, &hrec);
2348     ok(r == ERROR_SUCCESS, "select query failed\n");
2349     MsiCloseHandle(hrec);
2350
2351     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
2352     hrec = 0;
2353     r = do_query(hdb, query, &hrec);
2354     ok(r == ERROR_SUCCESS, "select query failed\n");
2355     MsiCloseHandle(hrec);
2356
2357     /* check updated values */
2358     hrec = 0;
2359     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
2360     r = do_query(hdb, query, &hrec);
2361     ok(r == ERROR_SUCCESS, "select query failed\n");
2362     MsiCloseHandle(hrec);
2363
2364     /* check unchanged value */
2365     hrec = 0;
2366     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
2367     r = do_query(hdb, query, &hrec);
2368     ok(r == ERROR_SUCCESS, "select query failed\n");
2369     MsiCloseHandle(hrec);
2370
2371     /* check deleted value */
2372     hrec = 0;
2373     query = "select * from `MOO` where `NOO` = 3";
2374     r = do_query(hdb, query, &hrec);
2375     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
2376     if (hrec) MsiCloseHandle(hrec);
2377
2378     /* check added stream */
2379     hrec = 0;
2380     query = "select `BLOB` from `BINARY` where `ID` = 1";
2381     r = do_query(hdb, query, &hrec);
2382     ok(r == ERROR_SUCCESS, "select query failed\n");
2383
2384     /* check the contents of the stream */
2385     sz = sizeof buffer;
2386     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
2387     ok(r == ERROR_SUCCESS, "read stream failed\n");
2388     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
2389     ok(sz == 9, "stream data was wrong size\n");
2390     if (hrec) MsiCloseHandle(hrec);
2391
2392     /* check the validity of the table with a deleted row */
2393     hrec = 0;
2394     query = "select * from `MOO`";
2395     r = MsiDatabaseOpenView(hdb, query, &hview);
2396     ok(r == ERROR_SUCCESS, "open view failed\n");
2397
2398     r = MsiViewExecute(hview, 0);
2399     ok(r == ERROR_SUCCESS, "view execute failed\n");
2400
2401     r = MsiViewFetch(hview, &hrec);
2402     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2403
2404     r = MsiRecordGetInteger(hrec, 1);
2405     ok(r == 1, "Expected 1, got %d\n", r);
2406
2407     sz = sizeof buffer;
2408     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2409     ok(r == ERROR_SUCCESS, "record get string failed\n");
2410     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
2411
2412     r = MsiRecordGetInteger(hrec, 3);
2413     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2414
2415     r = MsiRecordGetInteger(hrec, 4);
2416     ok(r == 5, "Expected 5, got %d\n", r);
2417
2418     MsiCloseHandle(hrec);
2419
2420     r = MsiViewFetch(hview, &hrec);
2421     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2422
2423     r = MsiRecordGetInteger(hrec, 1);
2424     ok(r == 2, "Expected 2, got %d\n", r);
2425
2426     sz = sizeof buffer;
2427     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2428     ok(r == ERROR_SUCCESS, "record get string failed\n");
2429     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
2430
2431     r = MsiRecordGetInteger(hrec, 3);
2432     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2433
2434     r = MsiRecordGetInteger(hrec, 4);
2435     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2436
2437     MsiCloseHandle(hrec);
2438
2439     r = MsiViewFetch(hview, &hrec);
2440     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
2441
2442     MsiCloseHandle(hrec);
2443     MsiCloseHandle(hview);
2444
2445     /* check that the property was added */
2446     hpkg = package_from_db(hdb);
2447     ok(hpkg != 0, "Expected non-NULL hpkg\n");
2448
2449     sz = MAX_PATH;
2450     r = MsiGetProperty(hpkg, "prop", buffer, &sz);
2451     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2452     ok(!lstrcmp(buffer, "val"), "Expected val, got %s\n", buffer);
2453
2454     MsiCloseHandle(hpkg);
2455     MsiCloseHandle(hdb);
2456
2457     DeleteFile(msifile);
2458     DeleteFile(mstfile);
2459 }
2460
2461 struct join_res
2462 {
2463     const CHAR one[MAX_PATH];
2464     const CHAR two[MAX_PATH];
2465 };
2466
2467 struct join_res_4col
2468 {
2469     const CHAR one[MAX_PATH];
2470     const CHAR two[MAX_PATH];
2471     const CHAR three[MAX_PATH];
2472     const CHAR four[MAX_PATH];
2473 };
2474
2475 struct join_res_uint
2476 {
2477     UINT one;
2478     UINT two;
2479     UINT three;
2480     UINT four;
2481     UINT five;
2482     UINT six;
2483 };
2484
2485 static const struct join_res join_res_first[] =
2486 {
2487     { "alveolar", "procerus" },
2488     { "septum", "procerus" },
2489     { "septum", "nasalis" },
2490     { "ramus", "nasalis" },
2491     { "malar", "mentalis" },
2492 };
2493
2494 static const struct join_res join_res_second[] =
2495 {
2496     { "nasal", "septum" },
2497     { "mandible", "ramus" },
2498 };
2499
2500 static const struct join_res join_res_third[] =
2501 {
2502     { "msvcp.dll", "abcdefgh" },
2503     { "msvcr.dll", "ijklmnop" },
2504 };
2505
2506 static const struct join_res join_res_fourth[] =
2507 {
2508     { "msvcp.dll.01234", "single.dll.31415" },
2509 };
2510
2511 static const struct join_res join_res_fifth[] =
2512 {
2513     { "malar", "procerus" },
2514 };
2515
2516 static const struct join_res join_res_sixth[] =
2517 {
2518     { "malar", "procerus" },
2519     { "malar", "procerus" },
2520     { "malar", "nasalis" },
2521     { "malar", "nasalis" },
2522     { "malar", "nasalis" },
2523     { "malar", "mentalis" },
2524 };
2525
2526 static const struct join_res join_res_seventh[] =
2527 {
2528     { "malar", "nasalis" },
2529     { "malar", "nasalis" },
2530     { "malar", "nasalis" },
2531 };
2532
2533 static const struct join_res_4col join_res_eighth[] =
2534 {
2535     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
2536     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
2537     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
2538     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
2539     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
2540     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
2541 };
2542
2543 static const struct join_res_uint join_res_ninth[] =
2544 {
2545     { 1, 2, 3, 4, 7, 8 },
2546     { 1, 2, 5, 6, 7, 8 },
2547     { 1, 2, 3, 4, 9, 10 },
2548     { 1, 2, 5, 6, 9, 10 },
2549     { 1, 2, 3, 4, 11, 12 },
2550     { 1, 2, 5, 6, 11, 12 },
2551 };
2552
2553 static void test_join(void)
2554 {
2555     MSIHANDLE hdb, hview, hrec;
2556     LPCSTR query;
2557     CHAR buf[MAX_PATH];
2558     UINT r, count;
2559     DWORD size, i;
2560     BOOL data_correct;
2561
2562     hdb = create_db();
2563     ok( hdb, "failed to create db\n");
2564
2565     r = create_component_table( hdb );
2566     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
2567
2568     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
2569     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2570
2571     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
2572     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2573
2574     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
2575     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2576
2577     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
2578     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2579
2580     r = create_feature_components_table( hdb );
2581     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
2582
2583     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
2584     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2585
2586     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
2587     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2588
2589     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
2590     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2591
2592     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
2593     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2594
2595     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
2596     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2597
2598     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
2599     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2600
2601     r = create_std_dlls_table( hdb );
2602     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
2603
2604     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
2605     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2606
2607     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
2608     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2609
2610     r = create_binary_table( hdb );
2611     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
2612
2613     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
2614     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2615
2616     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
2617     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2618
2619     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
2620     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2621
2622     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
2623     r = run_query( hdb, 0, query);
2624     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2625
2626     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
2627     r = run_query( hdb, 0, query);
2628     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2629
2630     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
2631     r = run_query( hdb, 0, query);
2632     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2633
2634     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
2635     r = run_query( hdb, 0, query);
2636     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2637
2638     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
2639     r = run_query( hdb, 0, query);
2640     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2641
2642     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
2643     r = run_query( hdb, 0, query);
2644     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2645
2646     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
2647     r = run_query( hdb, 0, query);
2648     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2649
2650     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
2651     r = run_query( hdb, 0, query);
2652     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2653
2654     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
2655     r = run_query( hdb, 0, query);
2656     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2657
2658     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
2659     r = run_query( hdb, 0, query);
2660     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2661
2662     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
2663     r = run_query( hdb, 0, query);
2664     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2665
2666     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
2667     r = run_query( hdb, 0, query);
2668     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2669
2670     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
2671     r = run_query( hdb, 0, query);
2672     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2673
2674     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2675             "FROM `Component`, `FeatureComponents` "
2676             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
2677             "ORDER BY `Feature_`";
2678     r = MsiDatabaseOpenView(hdb, query, &hview);
2679     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2680
2681     r = MsiViewExecute(hview, 0);
2682     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2683
2684     i = 0;
2685     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2686     {
2687         count = MsiRecordGetFieldCount( hrec );
2688         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2689
2690         size = MAX_PATH;
2691         r = MsiRecordGetString( hrec, 1, buf, &size );
2692         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2693         ok( !lstrcmp( buf, join_res_first[i].one ),
2694             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
2695
2696         size = MAX_PATH;
2697         r = MsiRecordGetString( hrec, 2, buf, &size );
2698         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2699         ok( !lstrcmp( buf, join_res_first[i].two ),
2700             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
2701
2702         i++;
2703         MsiCloseHandle(hrec);
2704     }
2705
2706     ok( i == 5, "Expected 5 rows, got %d\n", i );
2707     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2708
2709     MsiViewClose(hview);
2710     MsiCloseHandle(hview);
2711
2712     /* try a join without a WHERE condition */
2713     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2714             "FROM `Component`, `FeatureComponents` ";
2715     r = MsiDatabaseOpenView(hdb, query, &hview);
2716     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2717
2718     r = MsiViewExecute(hview, 0);
2719     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2720
2721     i = 0;
2722     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2723     {
2724         i++;
2725         MsiCloseHandle(hrec);
2726     }
2727     ok( i == 24, "Expected 24 rows, got %d\n", i );
2728
2729     MsiViewClose(hview);
2730     MsiCloseHandle(hview);
2731
2732     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
2733             "WHERE FeatureComponents.Component_=Component.Component "
2734             "AND (Feature_='nasalis') ORDER BY Feature_";
2735     r = MsiDatabaseOpenView(hdb, query, &hview);
2736     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2737
2738     r = MsiViewExecute(hview, 0);
2739     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2740
2741     i = 0;
2742     data_correct = TRUE;
2743     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2744     {
2745         count = MsiRecordGetFieldCount( hrec );
2746         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2747
2748         size = MAX_PATH;
2749         r = MsiRecordGetString( hrec, 1, buf, &size );
2750         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2751         if( lstrcmp( buf, join_res_second[i].one ))
2752             data_correct = FALSE;
2753
2754         size = MAX_PATH;
2755         r = MsiRecordGetString( hrec, 2, buf, &size );
2756         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2757         if( lstrcmp( buf, join_res_second[i].two ))
2758             data_correct = FALSE;
2759
2760         i++;
2761         MsiCloseHandle(hrec);
2762     }
2763
2764     ok( data_correct, "data returned in the wrong order\n");
2765
2766     ok( i == 2, "Expected 2 rows, got %d\n", i );
2767     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2768
2769     MsiViewClose(hview);
2770     MsiCloseHandle(hview);
2771
2772     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2773             "FROM `StdDlls`, `Binary` "
2774             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
2775             "ORDER BY `File`";
2776     r = MsiDatabaseOpenView(hdb, query, &hview);
2777     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2778
2779     r = MsiViewExecute(hview, 0);
2780     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2781
2782     i = 0;
2783     data_correct = TRUE;
2784     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2785     {
2786         count = MsiRecordGetFieldCount( hrec );
2787         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2788
2789         size = MAX_PATH;
2790         r = MsiRecordGetString( hrec, 1, buf, &size );
2791         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2792         if( lstrcmp( buf, join_res_third[i].one ) )
2793             data_correct = FALSE;
2794
2795         size = MAX_PATH;
2796         r = MsiRecordGetString( hrec, 2, buf, &size );
2797         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2798         if( lstrcmp( buf, join_res_third[i].two ) )
2799             data_correct = FALSE;
2800
2801         i++;
2802         MsiCloseHandle(hrec);
2803     }
2804     ok( data_correct, "data returned in the wrong order\n");
2805
2806     ok( i == 2, "Expected 2 rows, got %d\n", i );
2807
2808     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2809
2810     MsiViewClose(hview);
2811     MsiCloseHandle(hview);
2812
2813     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
2814             "FROM `StdDlls`, `Binary` "
2815             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
2816             "ORDER BY `Name`";
2817     r = MsiDatabaseOpenView(hdb, query, &hview);
2818     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2819
2820     r = MsiViewExecute(hview, 0);
2821     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2822
2823     i = 0;
2824     data_correct = TRUE;
2825     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2826     {
2827         count = MsiRecordGetFieldCount( hrec );
2828         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2829
2830         size = MAX_PATH;
2831         r = MsiRecordGetString( hrec, 1, buf, &size );
2832         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2833         if( lstrcmp( buf, join_res_fourth[i].one ))
2834             data_correct = FALSE;
2835
2836         size = MAX_PATH;
2837         r = MsiRecordGetString( hrec, 2, buf, &size );
2838         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2839         if( lstrcmp( buf, join_res_fourth[i].two ))
2840             data_correct = FALSE;
2841
2842         i++;
2843         MsiCloseHandle(hrec);
2844     }
2845     ok( data_correct, "data returned in the wrong order\n");
2846
2847     ok( i == 1, "Expected 1 rows, got %d\n", i );
2848     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2849
2850     MsiViewClose(hview);
2851     MsiCloseHandle(hview);
2852
2853     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2854             "FROM `Component`, `FeatureComponents` "
2855             "WHERE `Component`.`Component` = 'zygomatic' "
2856             "AND `FeatureComponents`.`Component_` = 'maxilla' "
2857             "ORDER BY `Feature_`";
2858     r = MsiDatabaseOpenView(hdb, query, &hview);
2859     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2860
2861     r = MsiViewExecute(hview, 0);
2862     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2863
2864     i = 0;
2865     data_correct = TRUE;
2866     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2867     {
2868         count = MsiRecordGetFieldCount( hrec );
2869         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2870
2871         size = MAX_PATH;
2872         r = MsiRecordGetString( hrec, 1, buf, &size );
2873         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2874         if( lstrcmp( buf, join_res_fifth[i].one ))
2875             data_correct = FALSE;
2876
2877         size = MAX_PATH;
2878         r = MsiRecordGetString( hrec, 2, buf, &size );
2879         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2880         if( lstrcmp( buf, join_res_fifth[i].two ))
2881             data_correct = FALSE;
2882
2883         i++;
2884         MsiCloseHandle(hrec);
2885     }
2886     ok( data_correct, "data returned in the wrong order\n");
2887
2888     ok( i == 1, "Expected 1 rows, got %d\n", i );
2889     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2890
2891     MsiViewClose(hview);
2892     MsiCloseHandle(hview);
2893
2894     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2895             "FROM `Component`, `FeatureComponents` "
2896             "WHERE `Component` = 'zygomatic' "
2897             "ORDER BY `Feature_`";
2898     r = MsiDatabaseOpenView(hdb, query, &hview);
2899     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2900
2901     r = MsiViewExecute(hview, 0);
2902     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2903
2904     i = 0;
2905     data_correct = TRUE;
2906     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2907     {
2908         count = MsiRecordGetFieldCount( hrec );
2909         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2910
2911         size = MAX_PATH;
2912         r = MsiRecordGetString( hrec, 1, buf, &size );
2913         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2914         if( lstrcmp( buf, join_res_sixth[i].one ))
2915             data_correct = FALSE;
2916
2917         size = MAX_PATH;
2918         r = MsiRecordGetString( hrec, 2, buf, &size );
2919         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2920         if( lstrcmp( buf, join_res_sixth[i].two ))
2921             data_correct = FALSE;
2922
2923         i++;
2924         MsiCloseHandle(hrec);
2925     }
2926     ok( data_correct, "data returned in the wrong order\n");
2927
2928     ok( i == 6, "Expected 6 rows, got %d\n", i );
2929     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2930
2931     MsiViewClose(hview);
2932     MsiCloseHandle(hview);
2933
2934     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2935             "FROM `Component`, `FeatureComponents` "
2936             "WHERE `Component` = 'zygomatic' "
2937             "AND `Feature_` = 'nasalis' "
2938             "ORDER BY `Feature_`";
2939     r = MsiDatabaseOpenView(hdb, query, &hview);
2940     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2941
2942     r = MsiViewExecute(hview, 0);
2943     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2944
2945     i = 0;
2946     data_correct = TRUE;
2947     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2948     {
2949         count = MsiRecordGetFieldCount( hrec );
2950         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2951
2952         size = MAX_PATH;
2953         r = MsiRecordGetString( hrec, 1, buf, &size );
2954         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2955         if( lstrcmp( buf, join_res_seventh[i].one ))
2956             data_correct = FALSE;
2957
2958         size = MAX_PATH;
2959         r = MsiRecordGetString( hrec, 2, buf, &size );
2960         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2961         if( lstrcmp( buf, join_res_seventh[i].two ))
2962             data_correct = FALSE;
2963
2964         i++;
2965         MsiCloseHandle(hrec);
2966     }
2967
2968     ok( data_correct, "data returned in the wrong order\n");
2969     ok( i == 3, "Expected 3 rows, got %d\n", i );
2970     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2971
2972     MsiViewClose(hview);
2973     MsiCloseHandle(hview);
2974
2975     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2976             "FROM `StdDlls`, `Binary` ";
2977     r = MsiDatabaseOpenView(hdb, query, &hview);
2978     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2979
2980     r = MsiViewExecute(hview, 0);
2981     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2982
2983     i = 0;
2984     data_correct = TRUE;
2985     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2986     {
2987         count = MsiRecordGetFieldCount( hrec );
2988         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2989
2990         size = MAX_PATH;
2991         r = MsiRecordGetString( hrec, 1, buf, &size );
2992         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2993         if( lstrcmp( buf, join_res_eighth[i].one ))
2994             data_correct = FALSE;
2995
2996         size = MAX_PATH;
2997         r = MsiRecordGetString( hrec, 2, buf, &size );
2998         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2999         if( lstrcmp( buf, join_res_eighth[i].four ))
3000             data_correct = FALSE;
3001
3002         i++;
3003         MsiCloseHandle(hrec);
3004     }
3005
3006     ok( data_correct, "data returned in the wrong order\n");
3007     ok( i == 6, "Expected 6 rows, got %d\n", i );
3008     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3009
3010     MsiViewClose(hview);
3011     MsiCloseHandle(hview);
3012
3013     query = "SELECT * FROM `StdDlls`, `Binary` ";
3014     r = MsiDatabaseOpenView(hdb, query, &hview);
3015     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3016
3017     r = MsiViewExecute(hview, 0);
3018     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3019
3020     i = 0;
3021     data_correct = TRUE;
3022     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3023     {
3024         count = MsiRecordGetFieldCount( hrec );
3025         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3026
3027         size = MAX_PATH;
3028         r = MsiRecordGetString( hrec, 1, buf, &size );
3029         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3030         if( lstrcmp( buf, join_res_eighth[i].one ))
3031             data_correct = FALSE;
3032
3033         size = MAX_PATH;
3034         r = MsiRecordGetString( hrec, 2, buf, &size );
3035         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3036         if( lstrcmp( buf, join_res_eighth[i].two ))
3037             data_correct = FALSE;
3038
3039         size = MAX_PATH;
3040         r = MsiRecordGetString( hrec, 3, buf, &size );
3041         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3042         if( lstrcmp( buf, join_res_eighth[i].three ))
3043             data_correct = FALSE;
3044
3045         size = MAX_PATH;
3046         r = MsiRecordGetString( hrec, 4, buf, &size );
3047         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3048         if( lstrcmp( buf, join_res_eighth[i].four ))
3049             data_correct = FALSE;
3050
3051         i++;
3052         MsiCloseHandle(hrec);
3053     }
3054     ok( data_correct, "data returned in the wrong order\n");
3055
3056     ok( i == 6, "Expected 6 rows, got %d\n", i );
3057     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3058
3059     MsiViewClose(hview);
3060     MsiCloseHandle(hview);
3061
3062     query = "SELECT * FROM `One`, `Two`, `Three` ";
3063     r = MsiDatabaseOpenView(hdb, query, &hview);
3064     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3065
3066     r = MsiViewExecute(hview, 0);
3067     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3068
3069     i = 0;
3070     data_correct = TRUE;
3071     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3072     {
3073         count = MsiRecordGetFieldCount( hrec );
3074         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3075
3076         r = MsiRecordGetInteger( hrec, 1 );
3077         if( r != join_res_ninth[i].one )
3078             data_correct = FALSE;
3079
3080         r = MsiRecordGetInteger( hrec, 2 );
3081         if( r != join_res_ninth[i].two )
3082             data_correct = FALSE;
3083
3084         r = MsiRecordGetInteger( hrec, 3 );
3085         if( r != join_res_ninth[i].three )
3086             data_correct = FALSE;
3087
3088         r = MsiRecordGetInteger( hrec, 4 );
3089         if( r != join_res_ninth[i].four )
3090             data_correct = FALSE;
3091
3092         r = MsiRecordGetInteger( hrec, 5 );
3093         if( r != join_res_ninth[i].five )
3094             data_correct = FALSE;
3095
3096         r = MsiRecordGetInteger( hrec, 6);
3097         if( r != join_res_ninth[i].six )
3098             data_correct = FALSE;
3099
3100         i++;
3101         MsiCloseHandle(hrec);
3102     }
3103     ok( data_correct, "data returned in the wrong order\n");
3104
3105     ok( i == 6, "Expected 6 rows, got %d\n", i );
3106     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3107
3108     MsiViewClose(hview);
3109     MsiCloseHandle(hview);
3110
3111     query = "SELECT * FROM `Four`, `Five`";
3112     r = MsiDatabaseOpenView(hdb, query, &hview);
3113     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3114
3115     r = MsiViewExecute(hview, 0);
3116     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3117
3118     r = MsiViewFetch(hview, &hrec);
3119     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3120
3121     MsiViewClose(hview);
3122     MsiCloseHandle(hview);
3123
3124     MsiCloseHandle(hdb);
3125     DeleteFile(msifile);
3126 }
3127
3128 static void test_temporary_table(void)
3129 {
3130     MSICONDITION cond;
3131     MSIHANDLE hdb = 0, view = 0, rec;
3132     const char *query;
3133     UINT r;
3134     char buf[0x10];
3135     DWORD sz;
3136
3137     cond = MsiDatabaseIsTablePersistent(0, NULL);
3138     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3139
3140     hdb = create_db();
3141     ok( hdb, "failed to create db\n");
3142
3143     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
3144     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3145
3146     todo_wine {
3147     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
3148     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3149
3150     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
3151     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3152     }
3153
3154     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
3155     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3156
3157     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
3158     r = run_query(hdb, 0, query);
3159     ok(r == ERROR_SUCCESS, "failed to add table\n");
3160
3161     cond = MsiDatabaseIsTablePersistent(hdb, "P");
3162     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3163
3164     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
3165     r = run_query(hdb, 0, query);
3166     ok(r == ERROR_SUCCESS, "failed to add table\n");
3167
3168     cond = MsiDatabaseIsTablePersistent(hdb, "P2");
3169     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3170
3171     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
3172     r = run_query(hdb, 0, query);
3173     ok(r == ERROR_SUCCESS, "failed to add table\n");
3174
3175     cond = MsiDatabaseIsTablePersistent(hdb, "T");
3176     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
3177
3178     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3179     r = run_query(hdb, 0, query);
3180     ok(r == ERROR_SUCCESS, "failed to add table\n");
3181
3182     todo_wine {
3183     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
3184     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3185     }
3186
3187     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
3188     r = run_query(hdb, 0, query);
3189     ok(r == ERROR_SUCCESS, "failed to add table\n");
3190
3191     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
3192     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3193
3194     todo_wine {
3195     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3196     r = run_query(hdb, 0, query);
3197     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
3198
3199     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
3200     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3201     }
3202
3203     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
3204     r = run_query(hdb, 0, query);
3205     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
3206
3207     query = "select * from `T`";
3208     r = MsiDatabaseOpenView(hdb, query, &view);
3209     ok(r == ERROR_SUCCESS, "failed to query table\n");
3210     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
3211     ok(r == ERROR_SUCCESS, "failed to get column info\n");
3212
3213     sz = sizeof buf;
3214     r = MsiRecordGetString(rec, 1, buf, &sz);
3215     ok(r == ERROR_SUCCESS, "failed to get string\n");
3216     todo_wine ok( 0 == strcmp("G255", buf), "wrong column type\n");
3217
3218     sz = sizeof buf;
3219     r = MsiRecordGetString(rec, 2, buf, &sz);
3220     ok(r == ERROR_SUCCESS, "failed to get string\n");
3221     todo_wine ok( 0 == strcmp("j2", buf), "wrong column type\n");
3222
3223     MsiCloseHandle( rec );
3224     MsiCloseHandle( view );
3225
3226     /* query the table data */
3227     rec = 0;
3228     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
3229     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
3230     MsiCloseHandle( rec );
3231
3232     /* query the column data */
3233     rec = 0;
3234     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
3235     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3236     if (rec) MsiCloseHandle( rec );
3237
3238     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
3239     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3240     if (rec) MsiCloseHandle( rec );
3241
3242     MsiCloseHandle( hdb );
3243
3244     DeleteFile(msifile);
3245 }
3246
3247 static void test_alter(void)
3248 {
3249     MSICONDITION cond;
3250     MSIHANDLE hdb = 0;
3251     const char *query;
3252     UINT r;
3253
3254     hdb = create_db();
3255     ok( hdb, "failed to create db\n");
3256
3257     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
3258     r = run_query(hdb, 0, query);
3259     ok(r == ERROR_SUCCESS, "failed to add table\n");
3260
3261     cond = MsiDatabaseIsTablePersistent(hdb, "T");
3262     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
3263
3264     query = "ALTER TABLE `T` HOLD";
3265     r = run_query(hdb, 0, query);
3266     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
3267
3268     query = "ALTER TABLE `T` FREE";
3269     r = run_query(hdb, 0, query);
3270     ok(r == ERROR_SUCCESS, "failed to free table\n");
3271
3272     query = "ALTER TABLE `T` FREE";
3273     r = run_query(hdb, 0, query);
3274     ok(r == ERROR_SUCCESS, "failed to free table\n");
3275
3276     query = "ALTER TABLE `T` FREE";
3277     r = run_query(hdb, 0, query);
3278     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
3279
3280     query = "ALTER TABLE `T` HOLD";
3281     r = run_query(hdb, 0, query);
3282     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
3283
3284     /* table T is removed */
3285     query = "SELECT * FROM `T`";
3286     r = run_query(hdb, 0, query);
3287     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3288
3289     /* create the table again */
3290     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
3291     r = run_query(hdb, 0, query);
3292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3293
3294     /* up the ref count */
3295     query = "ALTER TABLE `U` HOLD";
3296     r = run_query(hdb, 0, query);
3297     ok(r == ERROR_SUCCESS, "failed to free table\n");
3298
3299     /* add column, no data type */
3300     query = "ALTER TABLE `U` ADD `C`";
3301     r = run_query(hdb, 0, query);
3302     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3303
3304     query = "ALTER TABLE `U` ADD `C` INTEGER";
3305     r = run_query(hdb, 0, query);
3306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3307
3308     /* add column C again */
3309     query = "ALTER TABLE `U` ADD `C` INTEGER";
3310     r = run_query(hdb, 0, query);
3311     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3312
3313     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
3314     r = run_query(hdb, 0, query);
3315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3316
3317     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
3318     r = run_query(hdb, 0, query);
3319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3320
3321     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
3322     r = run_query(hdb, 0, query);
3323     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3324
3325     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
3326     r = run_query(hdb, 0, query);
3327     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3328
3329     query = "SELECT * FROM `U` WHERE `D` = 8";
3330     r = run_query(hdb, 0, query);
3331     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3332
3333     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
3334     r = run_query(hdb, 0, query);
3335     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3336
3337     query = "ALTER COLUMN `D` FREE";
3338     r = run_query(hdb, 0, query);
3339     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3340
3341     /* drop the ref count */
3342     query = "ALTER TABLE `U` FREE";
3343     r = run_query(hdb, 0, query);
3344     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3345
3346     /* table is not empty */
3347     query = "SELECT * FROM `U`";
3348     r = run_query(hdb, 0, query);
3349     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3350
3351     /* column D is removed */
3352     query = "SELECT * FROM `U` WHERE `D` = 8";
3353     r = run_query(hdb, 0, query);
3354     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3355
3356     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
3357     r = run_query(hdb, 0, query);
3358     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3359
3360     /* add the column again */
3361     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
3362     r = run_query(hdb, 0, query);
3363     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3364
3365     /* up the ref count */
3366     query = "ALTER TABLE `U` HOLD";
3367     r = run_query(hdb, 0, query);
3368     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3369
3370     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
3371     r = run_query(hdb, 0, query);
3372     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3373
3374     query = "SELECT * FROM `U` WHERE `E` = 16";
3375     r = run_query(hdb, 0, query);
3376     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3377
3378     /* drop the ref count */
3379     query = "ALTER TABLE `U` FREE";
3380     r = run_query(hdb, 0, query);
3381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3382
3383     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
3384     r = run_query(hdb, 0, query);
3385     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3386
3387     query = "SELECT * FROM `U` WHERE `E` = 20";
3388     r = run_query(hdb, 0, query);
3389     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3390
3391     /* drop the ref count */
3392     query = "ALTER TABLE `U` FREE";
3393     r = run_query(hdb, 0, query);
3394     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3395
3396     /* table still exists */
3397     query = "SELECT * FROM `U`";
3398     r = run_query(hdb, 0, query);
3399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3400
3401     /* col E is removed */
3402     query = "SELECT * FROM `U` WHERE `E` = 20";
3403     r = run_query(hdb, 0, query);
3404     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3405
3406     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
3407     r = run_query(hdb, 0, query);
3408     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3409
3410     /* drop the ref count once more */
3411     query = "ALTER TABLE `U` FREE";
3412     r = run_query(hdb, 0, query);
3413     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3414
3415     /* table still exists */
3416     query = "SELECT * FROM `U`";
3417     r = run_query(hdb, 0, query);
3418     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3419
3420     MsiCloseHandle( hdb );
3421     DeleteFile(msifile);
3422 }
3423
3424 static void test_integers(void)
3425 {
3426     MSIHANDLE hdb = 0, view = 0, rec = 0;
3427     DWORD count, i;
3428     const char *query;
3429     UINT r;
3430
3431     /* just MsiOpenDatabase should not create a file */
3432     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3433     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3434
3435     /* create a table */
3436     query = "CREATE TABLE `integers` ( "
3437             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
3438             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
3439             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
3440             "PRIMARY KEY `one`)";
3441     r = MsiDatabaseOpenView(hdb, query, &view);
3442     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3443     r = MsiViewExecute(view, 0);
3444     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3445     r = MsiViewClose(view);
3446     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3447     r = MsiCloseHandle(view);
3448     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3449
3450     query = "SELECT * FROM `integers`";
3451     r = MsiDatabaseOpenView(hdb, query, &view);
3452     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3453
3454     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
3455     count = MsiRecordGetFieldCount(rec);
3456     ok(count == 8, "Expected 8, got %d\n", count);
3457     ok(check_record(rec, 1, "one"), "Expected one\n");
3458     ok(check_record(rec, 2, "two"), "Expected two\n");
3459     ok(check_record(rec, 3, "three"), "Expected three\n");
3460     ok(check_record(rec, 4, "four"), "Expected four\n");
3461     ok(check_record(rec, 5, "five"), "Expected five\n");
3462     ok(check_record(rec, 6, "six"), "Expected six\n");
3463     ok(check_record(rec, 7, "seven"), "Expected seven\n");
3464     ok(check_record(rec, 8, "eight"), "Expected eight\n");
3465     MsiCloseHandle(rec);
3466
3467     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
3468     count = MsiRecordGetFieldCount(rec);
3469     ok(count == 8, "Expected 8, got %d\n", count);
3470     ok(check_record(rec, 1, "I2"), "Expected I2\n");
3471     ok(check_record(rec, 2, "I2"), "Expected I2\n");
3472     ok(check_record(rec, 3, "I2"), "Expected I2\n");
3473     ok(check_record(rec, 4, "I4"), "Expected I4\n");
3474     ok(check_record(rec, 5, "i2"), "Expected i2\n");
3475     ok(check_record(rec, 6, "i2"), "Expected i2\n");
3476     ok(check_record(rec, 7, "i2"), "Expected i2\n");
3477     ok(check_record(rec, 8, "i4"), "Expected i4\n");
3478     MsiCloseHandle(rec);
3479
3480     MsiViewClose(view);
3481     MsiCloseHandle(view);
3482
3483     /* insert values into it, NULL where NOT NULL is specified */
3484     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
3485         "VALUES('', '', '', '', '', '', '', '')";
3486     r = MsiDatabaseOpenView(hdb, query, &view);
3487     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3488     r = MsiViewExecute(view, 0);
3489     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
3490
3491     MsiViewClose(view);
3492     MsiCloseHandle(view);
3493
3494     query = "SELECT * FROM `integers`";
3495     r = do_query(hdb, query, &rec);
3496     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3497
3498     r = MsiRecordGetFieldCount(rec);
3499     ok(r == -1, "record count wrong: %d\n", r);
3500
3501     MsiCloseHandle(rec);
3502
3503     /* insert legitimate values into it */
3504     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
3505         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
3506     r = MsiDatabaseOpenView(hdb, query, &view);
3507     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3508     r = MsiViewExecute(view, 0);
3509     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3510
3511     query = "SELECT * FROM `integers`";
3512     r = do_query(hdb, query, &rec);
3513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3514
3515     r = MsiRecordGetFieldCount(rec);
3516     ok(r == 8, "record count wrong: %d\n", r);
3517
3518     i = MsiRecordGetInteger(rec, 1);
3519     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
3520     i = MsiRecordGetInteger(rec, 3);
3521     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
3522     i = MsiRecordGetInteger(rec, 2);
3523     ok(i == 2, "Expected 2, got %d\n", i);
3524     i = MsiRecordGetInteger(rec, 4);
3525     ok(i == 4, "Expected 4, got %d\n", i);
3526     i = MsiRecordGetInteger(rec, 5);
3527     ok(i == 5, "Expected 5, got %d\n", i);
3528     i = MsiRecordGetInteger(rec, 6);
3529     ok(i == 6, "Expected 6, got %d\n", i);
3530     i = MsiRecordGetInteger(rec, 7);
3531     ok(i == 7, "Expected 7, got %d\n", i);
3532     i = MsiRecordGetInteger(rec, 8);
3533     ok(i == 8, "Expected 8, got %d\n", i);
3534
3535     MsiCloseHandle(rec);
3536     MsiViewClose(view);
3537     MsiCloseHandle(view);
3538
3539     r = MsiDatabaseCommit(hdb);
3540     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
3541
3542     r = MsiCloseHandle(hdb);
3543     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3544
3545     r = DeleteFile(msifile);
3546     ok(r == TRUE, "file didn't exist after commit\n");
3547 }
3548
3549 static void test_update(void)
3550 {
3551     MSIHANDLE hdb = 0, view = 0, rec = 0;
3552     CHAR result[MAX_PATH];
3553     const char *query;
3554     DWORD size;
3555     UINT r;
3556
3557     /* just MsiOpenDatabase should not create a file */
3558     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3559     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3560
3561     /* create the Control table */
3562     query = "CREATE TABLE `Control` ( "
3563         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
3564         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
3565         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
3566         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
3567     r = MsiDatabaseOpenView(hdb, query, &view);
3568     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3569     r = MsiViewExecute(view, 0);
3570     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3571     r = MsiViewClose(view);
3572     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3573     r = MsiCloseHandle(view);
3574     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3575
3576     /* add a control */
3577     query = "INSERT INTO `Control` ( "
3578         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3579         "`Property`, `Text`, `Control_Next`, `Help` )"
3580         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
3581     r = MsiDatabaseOpenView(hdb, query, &view);
3582     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3583     r = MsiViewExecute(view, 0);
3584     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3585     r = MsiViewClose(view);
3586     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3587     r = MsiCloseHandle(view);
3588     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3589
3590     /* add a second control */
3591     query = "INSERT INTO `Control` ( "
3592         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3593         "`Property`, `Text`, `Control_Next`, `Help` )"
3594         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
3595     r = MsiDatabaseOpenView(hdb, query, &view);
3596     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3597     r = MsiViewExecute(view, 0);
3598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3599     r = MsiViewClose(view);
3600     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3601     r = MsiCloseHandle(view);
3602     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3603
3604     /* add a third control */
3605     query = "INSERT INTO `Control` ( "
3606         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3607         "`Property`, `Text`, `Control_Next`, `Help` )"
3608         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
3609     r = MsiDatabaseOpenView(hdb, query, &view);
3610     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3611     r = MsiViewExecute(view, 0);
3612     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3613     r = MsiViewClose(view);
3614     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3615     r = MsiCloseHandle(view);
3616     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3617
3618     /* bad table */
3619     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3620     r = MsiDatabaseOpenView(hdb, query, &view);
3621     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3622
3623     /* bad set column */
3624     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3625     r = MsiDatabaseOpenView(hdb, query, &view);
3626     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3627
3628     /* bad where condition */
3629     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
3630     r = MsiDatabaseOpenView(hdb, query, &view);
3631     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3632
3633     /* just the dialog_ specified */
3634     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3635     r = MsiDatabaseOpenView(hdb, query, &view);
3636     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3637     r = MsiViewExecute(view, 0);
3638     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3639     r = MsiViewClose(view);
3640     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3641     r = MsiCloseHandle(view);
3642     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3643
3644     /* check the modified text */
3645     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3646     r = MsiDatabaseOpenView(hdb, query, &view);
3647     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3648     r = MsiViewExecute(view, 0);
3649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3650
3651     r = MsiViewFetch(view, &rec);
3652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3653
3654     size = MAX_PATH;
3655     r = MsiRecordGetString(rec, 1, result, &size);
3656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3657     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3658
3659     MsiCloseHandle(rec);
3660
3661     r = MsiViewFetch(view, &rec);
3662     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3663
3664     size = MAX_PATH;
3665     r = MsiRecordGetString(rec, 1, result, &size);
3666     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3667     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3668
3669     MsiCloseHandle(rec);
3670
3671     r = MsiViewFetch(view, &rec);
3672     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3673
3674     r = MsiViewClose(view);
3675     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3676     r = MsiCloseHandle(view);
3677     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3678
3679     /* dialog_ and control specified */
3680     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
3681     r = MsiDatabaseOpenView(hdb, query, &view);
3682     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3683     r = MsiViewExecute(view, 0);
3684     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3685     r = MsiViewClose(view);
3686     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3687     r = MsiCloseHandle(view);
3688     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3689
3690     /* check the modified text */
3691     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3692     r = MsiDatabaseOpenView(hdb, query, &view);
3693     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3694     r = MsiViewExecute(view, 0);
3695     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3696
3697     r = MsiViewFetch(view, &rec);
3698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3699
3700     size = MAX_PATH;
3701     r = MsiRecordGetString(rec, 1, result, &size);
3702     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3703     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3704
3705     MsiCloseHandle(rec);
3706
3707     r = MsiViewFetch(view, &rec);
3708     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3709
3710     size = MAX_PATH;
3711     r = MsiRecordGetString(rec, 1, result, &size);
3712     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3713     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3714
3715     MsiCloseHandle(rec);
3716
3717     r = MsiViewFetch(view, &rec);
3718     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3719
3720     r = MsiViewClose(view);
3721     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3722     r = MsiCloseHandle(view);
3723     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3724
3725     /* no where condition */
3726     query = "UPDATE `Control` SET `Text` = 'this is text'";
3727     r = MsiDatabaseOpenView(hdb, query, &view);
3728     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3729     r = MsiViewExecute(view, 0);
3730     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3731     r = MsiViewClose(view);
3732     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3733     r = MsiCloseHandle(view);
3734     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3735
3736     /* check the modified text */
3737     query = "SELECT `Text` FROM `Control`";
3738     r = MsiDatabaseOpenView(hdb, query, &view);
3739     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3740     r = MsiViewExecute(view, 0);
3741     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3742
3743     r = MsiViewFetch(view, &rec);
3744     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3745
3746     size = MAX_PATH;
3747     r = MsiRecordGetString(rec, 1, result, &size);
3748     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3749     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3750
3751     MsiCloseHandle(rec);
3752
3753     r = MsiViewFetch(view, &rec);
3754     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3755
3756     size = MAX_PATH;
3757     r = MsiRecordGetString(rec, 1, result, &size);
3758     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3759     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3760
3761     MsiCloseHandle(rec);
3762
3763     r = MsiViewFetch(view, &rec);
3764     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3765
3766     size = MAX_PATH;
3767     r = MsiRecordGetString(rec, 1, result, &size);
3768     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3769     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3770
3771     MsiCloseHandle(rec);
3772
3773     r = MsiViewFetch(view, &rec);
3774     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3775
3776     r = MsiViewClose(view);
3777     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3778     r = MsiCloseHandle(view);
3779     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3780
3781     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
3782         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
3783     r = run_query(hdb, 0, query);
3784     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3785
3786     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3787         "VALUES('one', 'two', 3)";
3788     r = run_query(hdb, 0, query);
3789     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3790
3791     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3792         "VALUES('three', 'four', 5)";
3793     r = run_query(hdb, 0, query);
3794     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3795
3796     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3797         "VALUES('six', 'two', 7)";
3798     r = run_query(hdb, 0, query);
3799     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3800
3801     rec = MsiCreateRecord(2);
3802     MsiRecordSetInteger(rec, 1, 8);
3803     MsiRecordSetString(rec, 2, "two");
3804
3805     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
3806     r = run_query(hdb, rec, query);
3807     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3808
3809     MsiCloseHandle(rec);
3810
3811     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
3812     r = MsiDatabaseOpenView(hdb, query, &view);
3813     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3814     r = MsiViewExecute(view, 0);
3815     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3816
3817     r = MsiViewFetch(view, &rec);
3818     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3819
3820     r = MsiRecordGetInteger(rec, 1);
3821     ok(r == 8, "Expected 8, got %d\n", r);
3822
3823     MsiCloseHandle(rec);
3824
3825     r = MsiViewFetch(view, &rec);
3826     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3827
3828     r = MsiRecordGetInteger(rec, 1);
3829     ok(r == 8, "Expected 8, got %d\n", r);
3830
3831     MsiCloseHandle(rec);
3832
3833     r = MsiViewFetch(view, &rec);
3834     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3835
3836     r = MsiRecordGetInteger(rec, 1);
3837     ok(r == 5, "Expected 5, got %d\n", r);
3838
3839     MsiCloseHandle(rec);
3840
3841     r = MsiViewFetch(view, &rec);
3842     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
3843
3844     MsiViewClose(view);
3845     MsiCloseHandle(view);
3846
3847     r = MsiDatabaseCommit(hdb);
3848     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
3849     r = MsiCloseHandle(hdb);
3850     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3851
3852     DeleteFile(msifile);
3853 }
3854
3855 static void test_special_tables(void)
3856 {
3857     const char *query;
3858     MSIHANDLE hdb = 0;
3859     UINT r;
3860
3861     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3862     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3863
3864     query = "CREATE TABLE `_Properties` ( "
3865         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3866     r = run_query(hdb, 0, query);
3867     ok(r == ERROR_SUCCESS, "failed to create table\n");
3868
3869     query = "CREATE TABLE `_Streams` ( "
3870         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3871     r = run_query(hdb, 0, query);
3872     todo_wine ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
3873
3874     query = "CREATE TABLE `_Tables` ( "
3875         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3876     r = run_query(hdb, 0, query);
3877     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
3878
3879     query = "CREATE TABLE `_Columns` ( "
3880         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3881     r = run_query(hdb, 0, query);
3882     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
3883
3884     r = MsiCloseHandle(hdb);
3885     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3886 }
3887
3888 static void test_select_markers(void)
3889 {
3890     MSIHANDLE hdb = 0, rec, view, res;
3891     LPCSTR query;
3892     UINT r;
3893     DWORD size;
3894     CHAR buf[MAX_PATH];
3895
3896     hdb = create_db();
3897     ok( hdb, "failed to create db\n");
3898
3899     r = run_query(hdb, 0,
3900             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
3901     ok(r == S_OK, "cannot create table: %d\n", r);
3902
3903     r = run_query(hdb, 0, "INSERT INTO `Table` "
3904             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
3905     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3906
3907     r = run_query(hdb, 0, "INSERT INTO `Table` "
3908             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
3909     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3910
3911     r = run_query(hdb, 0, "INSERT INTO `Table` "
3912             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
3913     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3914
3915     r = run_query(hdb, 0, "INSERT INTO `Table` "
3916             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
3917     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3918
3919     rec = MsiCreateRecord(2);
3920     MsiRecordSetString(rec, 1, "apple");
3921     MsiRecordSetString(rec, 2, "two");
3922
3923     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
3924     r = MsiDatabaseOpenView(hdb, query, &view);
3925     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3926
3927     r = MsiViewExecute(view, rec);
3928     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3929
3930     r = MsiViewFetch(view, &res);
3931     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3932
3933     size = MAX_PATH;
3934     r = MsiRecordGetString(res, 1, buf, &size);
3935     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3936     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
3937
3938     size = MAX_PATH;
3939     r = MsiRecordGetString(res, 2, buf, &size);
3940     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3941     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
3942
3943     r = MsiRecordGetInteger(res, 3);
3944     ok(r == 1, "Expected 1, got %d\n", r);
3945
3946     MsiCloseHandle(res);
3947
3948     r = MsiViewFetch(view, &res);
3949     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3950
3951     size = MAX_PATH;
3952     r = MsiRecordGetString(res, 1, buf, &size);
3953     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3954     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
3955
3956     size = MAX_PATH;
3957     r = MsiRecordGetString(res, 2, buf, &size);
3958     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3959     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
3960
3961     r = MsiRecordGetInteger(res, 3);
3962     ok(r == 2, "Expected 2, got %d\n", r);
3963
3964     MsiCloseHandle(res);
3965
3966     r = MsiViewFetch(view, &res);
3967     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3968
3969     MsiCloseHandle(rec);
3970     MsiViewClose(view);
3971     MsiCloseHandle(view);
3972
3973     rec = MsiCreateRecord(2);
3974     MsiRecordSetString(rec, 1, "one");
3975     MsiRecordSetInteger(rec, 2, 1);
3976
3977     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
3978     r = MsiDatabaseOpenView(hdb, query, &view);
3979     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3980     r = MsiViewExecute(view, rec);
3981     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3982
3983     r = MsiViewFetch(view, &res);
3984     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3985
3986     size = MAX_PATH;
3987     r = MsiRecordGetString(res, 1, buf, &size);
3988     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3989     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
3990
3991     size = MAX_PATH;
3992     r = MsiRecordGetString(res, 2, buf, &size);
3993     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3994     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
3995
3996     r = MsiRecordGetInteger(res, 3);
3997     ok(r == 2, "Expected 2, got %d\n", r);
3998
3999     MsiCloseHandle(res);
4000
4001     r = MsiViewFetch(view, &res);
4002     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4003
4004     size = MAX_PATH;
4005     r = MsiRecordGetString(res, 1, buf, &size);
4006     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4007     ok(!lstrcmp(buf, "banana"), "Expected banana, got %s\n", buf);
4008
4009     size = MAX_PATH;
4010     r = MsiRecordGetString(res, 2, buf, &size);
4011     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4012     ok(!lstrcmp(buf, "three"), "Expected three, got %s\n", buf);
4013
4014     r = MsiRecordGetInteger(res, 3);
4015     ok(r == 3, "Expected 3, got %d\n", r);
4016
4017     MsiCloseHandle(res);
4018
4019     r = MsiViewFetch(view, &res);
4020     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4021
4022     MsiCloseHandle(rec);
4023     MsiViewClose(view);
4024     MsiCloseHandle(view);
4025     MsiCloseHandle(hdb);
4026     DeleteFile(msifile);
4027 }
4028
4029 static void test_viewmodify_update(void)
4030 {
4031     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4032     const char *query;
4033     UINT r;
4034
4035     DeleteFile(msifile);
4036
4037     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4038     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4039
4040     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
4041     r = run_query( hdb, 0, query );
4042     ok(r == ERROR_SUCCESS, "query failed\n");
4043
4044     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
4045     r = run_query( hdb, 0, query );
4046     ok(r == ERROR_SUCCESS, "query failed\n");
4047
4048     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
4049     r = run_query( hdb, 0, query );
4050     ok(r == ERROR_SUCCESS, "query failed\n");
4051
4052     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
4053     r = run_query( hdb, 0, query );
4054     ok(r == ERROR_SUCCESS, "query failed\n");
4055
4056     query = "SELECT `B` FROM `table`";
4057     r = MsiDatabaseOpenView(hdb, query, &hview);
4058     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4059     r = MsiViewExecute(hview, 0);
4060     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4061     r = MsiViewFetch(hview, &hrec);
4062     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4063
4064     r = MsiRecordSetInteger(hrec, 1, 0);
4065     ok(r == ERROR_SUCCESS, "failed to set integer\n");
4066
4067     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4068     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
4069
4070     r = MsiCloseHandle(hrec);
4071     ok(r == ERROR_SUCCESS, "failed to close record\n");
4072
4073     r = MsiViewClose(hview);
4074     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4075     r = MsiCloseHandle(hview);
4076     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4077
4078     query = "SELECT * FROM `table`";
4079     r = MsiDatabaseOpenView(hdb, query, &hview);
4080     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4081     r = MsiViewExecute(hview, 0);
4082     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4083     r = MsiViewFetch(hview, &hrec);
4084     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4085
4086     r = MsiRecordGetInteger(hrec, 1);
4087     ok(r == 1, "Expected 1, got %d\n", r);
4088     r = MsiRecordGetInteger(hrec, 2);
4089     ok(r == 0, "Expected 0, got %d\n", r);
4090
4091     r = MsiCloseHandle(hrec);
4092     ok(r == ERROR_SUCCESS, "failed to close record\n");
4093
4094     r = MsiViewFetch(hview, &hrec);
4095     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4096
4097     r = MsiRecordGetInteger(hrec, 1);
4098     ok(r == 3, "Expected 3, got %d\n", r);
4099     r = MsiRecordGetInteger(hrec, 2);
4100     ok(r == 4, "Expected 4, got %d\n", r);
4101
4102     r = MsiCloseHandle(hrec);
4103     ok(r == ERROR_SUCCESS, "failed to close record\n");
4104
4105     r = MsiViewFetch(hview, &hrec);
4106     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4107
4108     r = MsiRecordGetInteger(hrec, 1);
4109     ok(r == 5, "Expected 5, got %d\n", r);
4110     r = MsiRecordGetInteger(hrec, 2);
4111     ok(r == 6, "Expected 6, got %d\n", r);
4112
4113     r = MsiCloseHandle(hrec);
4114     ok(r == ERROR_SUCCESS, "failed to close record\n");
4115
4116     r = MsiViewFetch(hview, &hrec);
4117     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4118
4119     r = MsiViewClose(hview);
4120     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4121     r = MsiCloseHandle(hview);
4122     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4123
4124     /* loop through all elements */
4125     query = "SELECT `B` FROM `table`";
4126     r = MsiDatabaseOpenView(hdb, query, &hview);
4127     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4128     r = MsiViewExecute(hview, 0);
4129     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4130
4131     while (TRUE)
4132     {
4133         r = MsiViewFetch(hview, &hrec);
4134         if (r != ERROR_SUCCESS)
4135             break;
4136
4137         r = MsiRecordSetInteger(hrec, 1, 0);
4138         ok(r == ERROR_SUCCESS, "failed to set integer\n");
4139
4140         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4141         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
4142
4143         r = MsiCloseHandle(hrec);
4144         ok(r == ERROR_SUCCESS, "failed to close record\n");
4145     }
4146
4147     r = MsiViewClose(hview);
4148     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4149     r = MsiCloseHandle(hview);
4150     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4151
4152     query = "SELECT * FROM `table`";
4153     r = MsiDatabaseOpenView(hdb, query, &hview);
4154     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4155     r = MsiViewExecute(hview, 0);
4156     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4157     r = MsiViewFetch(hview, &hrec);
4158     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4159
4160     r = MsiRecordGetInteger(hrec, 1);
4161     ok(r == 1, "Expected 1, got %d\n", r);
4162     r = MsiRecordGetInteger(hrec, 2);
4163     ok(r == 0, "Expected 0, got %d\n", r);
4164
4165     r = MsiCloseHandle(hrec);
4166     ok(r == ERROR_SUCCESS, "failed to close record\n");
4167
4168     r = MsiViewFetch(hview, &hrec);
4169     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4170
4171     r = MsiRecordGetInteger(hrec, 1);
4172     ok(r == 3, "Expected 3, got %d\n", r);
4173     r = MsiRecordGetInteger(hrec, 2);
4174     ok(r == 0, "Expected 0, got %d\n", r);
4175
4176     r = MsiCloseHandle(hrec);
4177     ok(r == ERROR_SUCCESS, "failed to close record\n");
4178
4179     r = MsiViewFetch(hview, &hrec);
4180     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4181
4182     r = MsiRecordGetInteger(hrec, 1);
4183     ok(r == 5, "Expected 5, got %d\n", r);
4184     r = MsiRecordGetInteger(hrec, 2);
4185     ok(r == 0, "Expected 0, got %d\n", r);
4186
4187     r = MsiCloseHandle(hrec);
4188     ok(r == ERROR_SUCCESS, "failed to close record\n");
4189
4190     r = MsiViewFetch(hview, &hrec);
4191     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4192
4193     r = MsiViewClose(hview);
4194     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4195     r = MsiCloseHandle(hview);
4196     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4197
4198     r = MsiCloseHandle( hdb );
4199     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
4200 }
4201
4202 static const WCHAR data10[] = { /* MOO */
4203     0x8001, 0x000b,
4204 };
4205 static const WCHAR data11[] = { /* AAR */
4206     0x8002, 0x8005,
4207     0x000c, 0x000f,
4208 };
4209 static const char data12[] = /* _StringData */
4210     "MOOABAARCDonetwofourfive";
4211 static const WCHAR data13[] = { /* _StringPool */
4212 /*  len, refs */
4213     0,   0,    /* string 0 ''     */
4214     0,   0,    /* string 1 ''     */
4215     0,   0,    /* string 2 ''     */
4216     0,   0,    /* string 3 ''     */
4217     0,   0,    /* string 4 ''     */
4218     3,   3,    /* string 5 'MOO'  */
4219     1,   1,    /* string 6 'A'    */
4220     1,   1,    /* string 7 'B'    */
4221     3,   3,    /* string 8 'AAR'  */
4222     1,   1,    /* string 9 'C'    */
4223     1,   1,    /* string a 'D'    */
4224     3,   1,    /* string b 'one'  */
4225     3,   1,    /* string c 'two'  */
4226     0,   0,    /* string d ''     */
4227     4,   1,    /* string e 'four' */
4228     4,   1,    /* string f 'five' */
4229 };
4230
4231 static void test_stringtable(void)
4232 {
4233     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4234     IStorage *stg = NULL;
4235     IStream *stm;
4236     WCHAR name[0x20];
4237     HRESULT hr;
4238     const char *query;
4239     char buffer[MAX_PATH];
4240     WCHAR data[MAX_PATH];
4241     DWORD sz, read;
4242     UINT r;
4243
4244     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
4245     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
4246     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
4247     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
4248     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
4249
4250     DeleteFile(msifile);
4251
4252     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4253     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4254
4255     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
4256     r = run_query(hdb, 0, query);
4257     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4258
4259     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
4260     r = run_query(hdb, 0, query);
4261     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4262
4263     /* insert persistent row */
4264     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
4265     r = run_query(hdb, 0, query);
4266     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4267
4268     /* insert persistent row */
4269     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
4270     r = run_query(hdb, 0, query);
4271     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4272
4273     /* open a view */
4274     query = "SELECT * FROM `MOO`";
4275     r = MsiDatabaseOpenView(hdb, query, &hview);
4276     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4277     r = MsiViewExecute(hview, 0);
4278     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4279
4280     hrec = MsiCreateRecord(2);
4281
4282     r = MsiRecordSetInteger(hrec, 1, 3);
4283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4284     r = MsiRecordSetString(hrec, 2, "three");
4285     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4286
4287     /* insert a nonpersistent row */
4288     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
4289     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4290
4291     r = MsiCloseHandle(hrec);
4292     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4293     r = MsiViewClose(hview);
4294     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4295     r = MsiCloseHandle(hview);
4296     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4297
4298     /* insert persistent row */
4299     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
4300     r = run_query(hdb, 0, query);
4301     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4302
4303     /* insert persistent row */
4304     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
4305     r = run_query(hdb, 0, query);
4306     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4307
4308     r = MsiDatabaseCommit(hdb);
4309     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4310
4311     r = MsiCloseHandle(hdb);
4312     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4313
4314     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
4315     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4316
4317     query = "SELECT * FROM `MOO`";
4318     r = MsiDatabaseOpenView(hdb, query, &hview);
4319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4320
4321     r = MsiViewExecute(hview, 0);
4322     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4323
4324     r = MsiViewFetch(hview, &hrec);
4325     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4326
4327     r = MsiRecordGetFieldCount(hrec);
4328     ok(r == 2, "Expected 2, got %d\n", r);
4329
4330     r = MsiRecordGetInteger(hrec, 1);
4331     ok(r == 1, "Expected 1, got %d\n", r);
4332
4333     sz = sizeof(buffer);
4334     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4335     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4336     ok(!lstrcmp(buffer, "one"), "Expected one, got %s\n", buffer);
4337
4338     r = MsiCloseHandle(hrec);
4339     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4340
4341     r = MsiViewFetch(hview, &hrec);
4342     todo_wine
4343     {
4344         ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4345     }
4346
4347     r = MsiViewClose(hview);
4348     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4349     r = MsiCloseHandle(hview);
4350     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4351     r = MsiCloseHandle(hrec);
4352     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4353
4354     query = "SELECT * FROM `AAR`";
4355     r = MsiDatabaseOpenView(hdb, query, &hview);
4356     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4357
4358     r = MsiViewExecute(hview, 0);
4359     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4360
4361     r = MsiViewFetch(hview, &hrec);
4362     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4363
4364     r = MsiRecordGetFieldCount(hrec);
4365     ok(r == 2, "Expected 2, got %d\n", r);
4366
4367     r = MsiRecordGetInteger(hrec, 1);
4368     ok(r == 2, "Expected 2, got %d\n", r);
4369
4370     sz = sizeof(buffer);
4371     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4372     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4373     ok(!lstrcmp(buffer, "two"), "Expected two, got %s\n", buffer);
4374
4375     r = MsiCloseHandle(hrec);
4376     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4377
4378     r = MsiViewFetch(hview, &hrec);
4379     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4380
4381     r = MsiRecordGetFieldCount(hrec);
4382     ok(r == 2, "Expected 2, got %d\n", r);
4383
4384     r = MsiRecordGetInteger(hrec, 1);
4385     ok(r == 5, "Expected 5, got %d\n", r);
4386
4387     sz = sizeof(buffer);
4388     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4389     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4390     ok(!lstrcmp(buffer, "five"), "Expected five, got %s\n", buffer);
4391
4392     r = MsiCloseHandle(hrec);
4393     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4394
4395     r = MsiViewFetch(hview, &hrec);
4396     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4397
4398     r = MsiViewClose(hview);
4399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4400     r = MsiCloseHandle(hview);
4401     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4402     r = MsiCloseHandle(hrec);
4403     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4404     r = MsiCloseHandle(hdb);
4405     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4406
4407     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
4408     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
4409     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4410     ok(stg != NULL, "Expected non-NULL storage\n");
4411
4412     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4413     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4414     ok(stm != NULL, "Expected non-NULL stream\n");
4415
4416     hr = IStream_Read(stm, data, MAX_PATH, &read);
4417     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4418     todo_wine
4419     {
4420         ok(read == 4, "Expected 4, got %d\n", read);
4421         ok(!memcmp(data, data10, read), "Unexpected data\n");
4422     }
4423
4424     hr = IStream_Release(stm);
4425     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4426
4427     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4428     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4429     ok(stm != NULL, "Expected non-NULL stream\n");
4430
4431     hr = IStream_Read(stm, data, MAX_PATH, &read);
4432     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4433     ok(read == 8, "Expected 8, got %d\n", read);
4434     todo_wine
4435     {
4436         ok(!memcmp(data, data11, read), "Unexpected data\n");
4437     }
4438
4439     hr = IStream_Release(stm);
4440     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4441
4442     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4443     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4444     ok(stm != NULL, "Expected non-NULL stream\n");
4445
4446     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
4447     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4448     ok(read == 24, "Expected 24, got %d\n", read);
4449     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
4450
4451     hr = IStream_Release(stm);
4452     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4453
4454     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4455     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4456     ok(stm != NULL, "Expected non-NULL stream\n");
4457
4458     hr = IStream_Read(stm, data, MAX_PATH, &read);
4459     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4460     todo_wine
4461     {
4462         ok(read == 64, "Expected 64, got %d\n", read);
4463         ok(!memcmp(data, data13, read), "Unexpected data\n");
4464     }
4465
4466     hr = IStream_Release(stm);
4467     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4468
4469     hr = IStorage_Release(stg);
4470     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4471
4472     DeleteFileA(msifile);
4473 }
4474
4475 static void test_viewmodify_delete(void)
4476 {
4477     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4478     UINT r;
4479     const char *query;
4480     char buffer[0x100];
4481     DWORD sz;
4482
4483     DeleteFile(msifile);
4484
4485     /* just MsiOpenDatabase should not create a file */
4486     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4487     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4488
4489     query = "CREATE TABLE `phone` ( "
4490             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
4491             "PRIMARY KEY `id`)";
4492     r = run_query(hdb, 0, query);
4493     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4494
4495     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4496         "VALUES('1', 'Alan', '5030581')";
4497     r = run_query(hdb, 0, query);
4498     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4499
4500     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4501         "VALUES('2', 'Barry', '928440')";
4502     r = run_query(hdb, 0, query);
4503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4504
4505     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4506         "VALUES('3', 'Cindy', '2937550')";
4507     r = run_query(hdb, 0, query);
4508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4509
4510     query = "SELECT * FROM `phone` WHERE `id` <= 2";
4511     r = MsiDatabaseOpenView(hdb, query, &hview);
4512     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4513     r = MsiViewExecute(hview, 0);
4514     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4515     r = MsiViewFetch(hview, &hrec);
4516     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4517
4518     /* delete 1 */
4519     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4520     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4521
4522     r = MsiCloseHandle(hrec);
4523     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4524     r = MsiViewFetch(hview, &hrec);
4525     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4526
4527     /* delete 2 */
4528     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4529     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4530
4531     r = MsiCloseHandle(hrec);
4532     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4533     r = MsiViewClose(hview);
4534     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4535     r = MsiCloseHandle(hview);
4536     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4537
4538     query = "SELECT * FROM `phone`";
4539     r = MsiDatabaseOpenView(hdb, query, &hview);
4540     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4541     r = MsiViewExecute(hview, 0);
4542     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4543     r = MsiViewFetch(hview, &hrec);
4544     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4545
4546     r = MsiRecordGetInteger(hrec, 1);
4547     ok(r == 3, "Expected 3, got %d\n", r);
4548
4549     sz = sizeof(buffer);
4550     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4551     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4552     ok(!lstrcmp(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
4553
4554     sz = sizeof(buffer);
4555     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4556     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4557     ok(!lstrcmp(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
4558
4559     r = MsiCloseHandle(hrec);
4560     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4561
4562     r = MsiViewFetch(hview, &hrec);
4563     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4564
4565     r = MsiViewClose(hview);
4566     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4567     r = MsiCloseHandle(hview);
4568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4569     r = MsiCloseHandle(hdb);
4570     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4571 }
4572
4573 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
4574 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
4575 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
4576
4577 static const WCHAR data14[] = { /* _StringPool */
4578 /*  len, refs */
4579     0,   0,    /* string 0 ''    */
4580 };
4581
4582 static const struct {
4583     LPCWSTR name;
4584     const void *data;
4585     DWORD size;
4586 } database_table_data[] =
4587 {
4588     {_Tables, NULL, 0},
4589     {_StringData, NULL, 0},
4590     {_StringPool, data14, sizeof data14},
4591 };
4592
4593 void enum_stream_names(IStorage *stg)
4594 {
4595     IEnumSTATSTG *stgenum = NULL;
4596     IStream *stm;
4597     HRESULT hr;
4598     STATSTG stat;
4599     ULONG n, count;
4600     BYTE data[MAX_PATH];
4601     BYTE check[MAX_PATH];
4602     DWORD sz;
4603
4604     memset(check, 'a', MAX_PATH);
4605
4606     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
4607     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4608
4609     n = 0;
4610     while(TRUE)
4611     {
4612         count = 0;
4613         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
4614         if(FAILED(hr) || !count)
4615             break;
4616
4617         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
4618            "Expected table %d name to match\n", n);
4619
4620         stm = NULL;
4621         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
4622                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4623         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4624         ok(stm != NULL, "Expected non-NULL stream\n");
4625
4626         sz = MAX_PATH;
4627         memset(data, 'a', MAX_PATH);
4628         hr = IStream_Read(stm, data, sz, &count);
4629         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4630
4631         ok(count == database_table_data[n].size,
4632            "Expected %d, got %d\n", database_table_data[n].size, count);
4633
4634         if (!database_table_data[n].size)
4635             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
4636         else
4637             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
4638                "Expected table %d data to match\n", n);
4639
4640         IStream_Release(stm);
4641         n++;
4642     }
4643
4644     ok(n == 3, "Expected 3, got %d\n", n);
4645
4646     IEnumSTATSTG_Release(stgenum);
4647 }
4648
4649 static void test_defaultdatabase(void)
4650 {
4651     UINT r;
4652     HRESULT hr;
4653     MSIHANDLE hdb;
4654     IStorage *stg = NULL;
4655
4656     static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','.','m','s','i',0};
4657
4658     DeleteFile(msifile);
4659
4660     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4662
4663     r = MsiDatabaseCommit(hdb);
4664     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4665
4666     MsiCloseHandle(hdb);
4667
4668     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
4669     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4670     ok(stg != NULL, "Expected non-NULL stg\n");
4671
4672     enum_stream_names(stg);
4673
4674     IStorage_Release(stg);
4675     DeleteFileA(msifile);
4676 }
4677
4678 static void test_order(void)
4679 {
4680     MSIHANDLE hdb, hview, hrec;
4681     LPCSTR query;
4682     UINT r;
4683     int val;
4684
4685     hdb = create_db();
4686     ok(hdb, "failed to create db\n");
4687
4688     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
4689     r = run_query(hdb, 0, query);
4690     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4691
4692     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
4693     r = run_query(hdb, 0, query);
4694     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4695
4696     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
4697     r = run_query(hdb, 0, query);
4698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4699
4700     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
4701     r = run_query(hdb, 0, query);
4702     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4703
4704     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
4705     r = run_query(hdb, 0, query);
4706     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4707
4708     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
4709     r = run_query(hdb, 0, query);
4710     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4711
4712     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
4713     r = run_query(hdb, 0, query);
4714     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4715
4716     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
4717     r = run_query(hdb, 0, query);
4718     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4719
4720     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
4721     r = MsiDatabaseOpenView(hdb, query, &hview);
4722     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4723     r = MsiViewExecute(hview, 0);
4724     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4725
4726     r = MsiViewFetch(hview, &hrec);
4727     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4728
4729     val = MsiRecordGetInteger(hrec, 1);
4730     ok(val == 3, "Expected 3, got %d\n", val);
4731
4732     val = MsiRecordGetInteger(hrec, 2);
4733     ok(val == 4, "Expected 3, got %d\n", val);
4734
4735     MsiCloseHandle(hrec);
4736
4737     r = MsiViewFetch(hview, &hrec);
4738     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4739
4740     val = MsiRecordGetInteger(hrec, 1);
4741     ok(val == 5, "Expected 5, got %d\n", val);
4742
4743     val = MsiRecordGetInteger(hrec, 2);
4744     ok(val == 6, "Expected 6, got %d\n", val);
4745
4746     MsiCloseHandle(hrec);
4747
4748     r = MsiViewFetch(hview, &hrec);
4749     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4750
4751     val = MsiRecordGetInteger(hrec, 1);
4752     ok(val == 1, "Expected 1, got %d\n", val);
4753
4754     val = MsiRecordGetInteger(hrec, 2);
4755     ok(val == 2, "Expected 2, got %d\n", val);
4756
4757     MsiCloseHandle(hrec);
4758
4759     r = MsiViewFetch(hview, &hrec);
4760     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4761
4762     MsiViewClose(hview);
4763     MsiCloseHandle(hview);
4764
4765     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
4766     r = MsiDatabaseOpenView(hdb, query, &hview);
4767     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4768     r = MsiViewExecute(hview, 0);
4769     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4770
4771     r = MsiViewFetch(hview, &hrec);
4772     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4773
4774     val = MsiRecordGetInteger(hrec, 1);
4775     ok(val == 1, "Expected 1, got %d\n", val);
4776
4777     val = MsiRecordGetInteger(hrec, 2);
4778     ok(val == 12, "Expected 12, got %d\n", val);
4779
4780     MsiCloseHandle(hrec);
4781
4782     r = MsiViewFetch(hview, &hrec);
4783     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4784
4785     val = MsiRecordGetInteger(hrec, 1);
4786     ok(val == 3, "Expected 3, got %d\n", val);
4787
4788     val = MsiRecordGetInteger(hrec, 2);
4789     ok(val == 12, "Expected 12, got %d\n", val);
4790
4791     MsiCloseHandle(hrec);
4792
4793     r = MsiViewFetch(hview, &hrec);
4794     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4795
4796     val = MsiRecordGetInteger(hrec, 1);
4797     ok(val == 5, "Expected 5, got %d\n", val);
4798
4799     val = MsiRecordGetInteger(hrec, 2);
4800     ok(val == 12, "Expected 12, got %d\n", val);
4801
4802     MsiCloseHandle(hrec);
4803
4804     r = MsiViewFetch(hview, &hrec);
4805     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4806
4807     val = MsiRecordGetInteger(hrec, 1);
4808     ok(val == 1, "Expected 1, got %d\n", val);
4809
4810     val = MsiRecordGetInteger(hrec, 2);
4811     ok(val == 14, "Expected 14, got %d\n", val);
4812
4813     MsiCloseHandle(hrec);
4814
4815     r = MsiViewFetch(hview, &hrec);
4816     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4817
4818     val = MsiRecordGetInteger(hrec, 1);
4819     ok(val == 3, "Expected 3, got %d\n", val);
4820
4821     val = MsiRecordGetInteger(hrec, 2);
4822     ok(val == 14, "Expected 14, got %d\n", val);
4823
4824     MsiCloseHandle(hrec);
4825
4826     r = MsiViewFetch(hview, &hrec);
4827     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4828
4829     val = MsiRecordGetInteger(hrec, 1);
4830     ok(val == 5, "Expected 5, got %d\n", val);
4831
4832     val = MsiRecordGetInteger(hrec, 2);
4833     ok(val == 14, "Expected 14, got %d\n", val);
4834
4835     MsiCloseHandle(hrec);
4836
4837     r = MsiViewFetch(hview, &hrec);
4838     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4839
4840     val = MsiRecordGetInteger(hrec, 1);
4841     ok(val == 1, "Expected 1, got %d\n", val);
4842
4843     val = MsiRecordGetInteger(hrec, 2);
4844     ok(val == 10, "Expected 10, got %d\n", val);
4845
4846     MsiCloseHandle(hrec);
4847
4848     r = MsiViewFetch(hview, &hrec);
4849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4850
4851     val = MsiRecordGetInteger(hrec, 1);
4852     ok(val == 3, "Expected 3, got %d\n", val);
4853
4854     val = MsiRecordGetInteger(hrec, 2);
4855     ok(val == 10, "Expected 10, got %d\n", val);
4856
4857     MsiCloseHandle(hrec);
4858
4859     r = MsiViewFetch(hview, &hrec);
4860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4861
4862     val = MsiRecordGetInteger(hrec, 1);
4863     ok(val == 5, "Expected 5, got %d\n", val);
4864
4865     val = MsiRecordGetInteger(hrec, 2);
4866     ok(val == 10, "Expected 10, got %d\n", val);
4867
4868     MsiCloseHandle(hrec);
4869
4870     r = MsiViewFetch(hview, &hrec);
4871     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4872
4873     MsiViewClose(hview);
4874     MsiCloseHandle(hview);
4875     MsiCloseHandle(hdb);
4876 }
4877
4878 static void test_viewmodify_delete_temporary(void)
4879 {
4880     MSIHANDLE hdb, hview, hrec;
4881     const char *query;
4882     UINT r;
4883
4884     DeleteFile(msifile);
4885
4886     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4887     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4888
4889     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
4890     r = run_query(hdb, 0, query);
4891     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4892
4893     query = "SELECT * FROM `Table`";
4894     r = MsiDatabaseOpenView(hdb, query, &hview);
4895     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4896     r = MsiViewExecute(hview, 0);
4897     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4898
4899     hrec = MsiCreateRecord(1);
4900     MsiRecordSetInteger(hrec, 1, 1);
4901
4902     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
4903     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4904
4905     MsiCloseHandle(hrec);
4906
4907     hrec = MsiCreateRecord(1);
4908     MsiRecordSetInteger(hrec, 1, 2);
4909
4910     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
4911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4912
4913     MsiCloseHandle(hrec);
4914
4915     hrec = MsiCreateRecord(1);
4916     MsiRecordSetInteger(hrec, 1, 3);
4917
4918     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
4919     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4920
4921     MsiCloseHandle(hrec);
4922
4923     hrec = MsiCreateRecord(1);
4924     MsiRecordSetInteger(hrec, 1, 4);
4925
4926     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
4927     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4928
4929     MsiCloseHandle(hrec);
4930     MsiViewClose(hview);
4931     MsiCloseHandle(hview);
4932
4933     query = "SELECT * FROM `Table` WHERE  `A` = 2";
4934     r = MsiDatabaseOpenView(hdb, query, &hview);
4935     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4936     r = MsiViewExecute(hview, 0);
4937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4938     r = MsiViewFetch(hview, &hrec);
4939     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4940
4941     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4942     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4943
4944     MsiCloseHandle(hrec);
4945     MsiViewClose(hview);
4946     MsiCloseHandle(hview);
4947
4948     query = "SELECT * FROM `Table` WHERE  `A` = 3";
4949     r = MsiDatabaseOpenView(hdb, query, &hview);
4950     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4951     r = MsiViewExecute(hview, 0);
4952     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4953     r = MsiViewFetch(hview, &hrec);
4954     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4955
4956     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4957     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4958
4959     MsiCloseHandle(hrec);
4960     MsiViewClose(hview);
4961     MsiCloseHandle(hview);
4962
4963     query = "SELECT * FROM `Table` ORDER BY `A`";
4964     r = MsiDatabaseOpenView(hdb, query, &hview);
4965     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4966     r = MsiViewExecute(hview, 0);
4967     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4968
4969     r = MsiViewFetch(hview, &hrec);
4970     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4971
4972     r = MsiRecordGetInteger(hrec, 1);
4973     ok(r == 1, "Expected 1, got %d\n", r);
4974
4975     MsiCloseHandle(hrec);
4976
4977     r = MsiViewFetch(hview, &hrec);
4978     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4979
4980     r = MsiRecordGetInteger(hrec, 1);
4981     ok(r == 4, "Expected 4, got %d\n", r);
4982
4983     MsiCloseHandle(hrec);
4984
4985     r = MsiViewFetch(hview, &hrec);
4986     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4987
4988     MsiViewClose(hview);
4989     MsiCloseHandle(hview);
4990     MsiCloseHandle(hdb);
4991     DeleteFileA(msifile);
4992 }
4993
4994 static void test_deleterow()
4995 {
4996     MSIHANDLE hdb, hview, hrec;
4997     const char *query;
4998     char buf[MAX_PATH];
4999     UINT r;
5000     DWORD size;
5001
5002     DeleteFile(msifile);
5003
5004     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5005     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5006
5007     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5008     r = run_query(hdb, 0, query);
5009     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5010
5011     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
5012     r = run_query(hdb, 0, query);
5013     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5014
5015     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
5016     r = run_query(hdb, 0, query);
5017     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5018
5019     query = "DELETE FROM `Table` WHERE `A` = 'one'";
5020     r = run_query(hdb, 0, query);
5021     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5022
5023     r = MsiDatabaseCommit(hdb);
5024     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5025
5026     MsiCloseHandle(hdb);
5027
5028     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
5029     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5030
5031     query = "SELECT * FROM `Table`";
5032     r = MsiDatabaseOpenView(hdb, query, &hview);
5033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5034     r = MsiViewExecute(hview, 0);
5035     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5036
5037     r = MsiViewFetch(hview, &hrec);
5038     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5039
5040     size = MAX_PATH;
5041     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5042     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5043     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5044
5045     MsiCloseHandle(hrec);
5046
5047     r = MsiViewFetch(hview, &hrec);
5048     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5049
5050     MsiViewClose(hview);
5051     MsiCloseHandle(hview);
5052     MsiCloseHandle(hdb);
5053     DeleteFileA(msifile);
5054 }
5055
5056 START_TEST(db)
5057 {
5058     test_msidatabase();
5059     test_msiinsert();
5060     test_msidecomposedesc();
5061     test_msibadqueries();
5062     test_viewmodify();
5063     test_viewgetcolumninfo();
5064     test_getcolinfo();
5065     test_msiexport();
5066     test_longstrings();
5067     test_streamtable();
5068     test_where();
5069     test_msiimport();
5070     test_markers();
5071     test_handle_limit();
5072     test_try_transform();
5073     test_join();
5074     test_temporary_table();
5075     test_alter();
5076     test_integers();
5077     test_update();
5078     test_special_tables();
5079     test_select_markers();
5080     test_viewmodify_update();
5081     test_stringtable();
5082     test_viewmodify_delete();
5083     test_defaultdatabase();
5084     test_order();
5085     test_viewmodify_delete_temporary();
5086     test_deleterow();
5087 }