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 const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
1594                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
1595                                 "Table\tA\r\n"
1596                                 "a\tb\tc\td\te\tf\n"
1597                                 "g\th\ti\t\rj\tk\tl\r\n";
1598
1599 static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
1600                                 "s72\ts72\ts72\ts72\ts72\ts72\n"
1601                                 "Table2\tA\r\n"
1602                                 "a\tb\tc\td\te\tf\n"
1603                                 "g\th\ti\tj\tk\tl\r\n";
1604
1605 static void write_file(const CHAR *filename, const char *data, int data_size)
1606 {
1607     DWORD size;
1608
1609     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1610                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1611
1612     WriteFile(hf, data, data_size, &size, NULL);
1613     CloseHandle(hf);
1614 }
1615
1616 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1617 {
1618     UINT r;
1619
1620     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1621     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1622     DeleteFileA("temp_file");
1623
1624     return r;
1625 }
1626
1627 static void test_msiimport(void)
1628 {
1629     MSIHANDLE hdb, view, rec;
1630     LPCSTR query;
1631     UINT r, count;
1632     signed int i;
1633
1634     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1635
1636     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1638
1639     r = add_table_to_db(hdb, test_data);
1640     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1641
1642     r = add_table_to_db(hdb, two_primary);
1643     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1644
1645     r = add_table_to_db(hdb, endlines1);
1646     if (r == ERROR_FUNCTION_FAILED)
1647     {
1648         /* win9x doesn't handle this case */
1649         skip("endlines not handled correctly.\n");
1650         MsiCloseHandle(hdb);
1651         DeleteFileA(msifile);
1652         return;
1653     }
1654
1655     r = add_table_to_db(hdb, endlines2);
1656     ok(r == ERROR_FUNCTION_FAILED,
1657        "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1658
1659     query = "SELECT * FROM `TestTable`";
1660     r = MsiDatabaseOpenView(hdb, query, &view);
1661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1662
1663     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1664     count = MsiRecordGetFieldCount(rec);
1665     ok(count == 9, "Expected 9, got %d\n", count);
1666     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1667     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1668     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1669     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1670     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1671     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1672     ok(check_record(rec, 7, "String"), "Expected String\n");
1673     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1674     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1675     MsiCloseHandle(rec);
1676
1677     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1678     count = MsiRecordGetFieldCount(rec);
1679     ok(count == 9, "Expected 9, got %d\n", count);
1680     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1681     ok(check_record(rec, 2, "i2"), "Expected i2\n");
1682     ok(check_record(rec, 3, "i2"), "Expected i2\n");
1683     ok(check_record(rec, 4, "I2"), "Expected I2\n");
1684     ok(check_record(rec, 5, "i4"), "Expected i4\n");
1685     ok(check_record(rec, 6, "I4"), "Expected I4\n");
1686     ok(check_record(rec, 7, "S255"), "Expected S255\n");
1687     ok(check_record(rec, 8, "S0"), "Expected S0\n");
1688     ok(check_record(rec, 9, "s0"), "Expected s0\n");
1689     MsiCloseHandle(rec);
1690
1691     query = "SELECT * FROM `TestTable`";
1692     r = do_query(hdb, query, &rec);
1693     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1694     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1695     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1696     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1697     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1698
1699     i = MsiRecordGetInteger(rec, 2);
1700     ok(i == 5, "Expected 5, got %d\n", i);
1701
1702     i = MsiRecordGetInteger(rec, 3);
1703     ok(i == 2, "Expected 2, got %d\n", i);
1704
1705     i = MsiRecordGetInteger(rec, 4);
1706     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
1707
1708     i = MsiRecordGetInteger(rec, 5);
1709     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1710
1711     i = MsiRecordGetInteger(rec, 6);
1712     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1713
1714     MsiCloseHandle(rec);
1715     MsiCloseHandle(view);
1716
1717     query = "SELECT * FROM `TwoPrimary`";
1718     r = MsiDatabaseOpenView(hdb, query, &view);
1719     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1720
1721     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1722     count = MsiRecordGetFieldCount(rec);
1723     ok(count == 2, "Expected 2, got %d\n", count);
1724     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
1725     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
1726
1727     MsiCloseHandle(rec);
1728
1729     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1730     count = MsiRecordGetFieldCount(rec);
1731     ok(count == 2, "Expected 2, got %d\n", count);
1732     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1733     ok(check_record(rec, 2, "s255"), "Expected s255\n");
1734     MsiCloseHandle(rec);
1735
1736     r = MsiViewExecute(view, 0);
1737     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1738
1739     r = MsiViewFetch(view, &rec);
1740     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1741
1742     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1743     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
1744
1745     MsiCloseHandle(rec);
1746
1747     r = MsiViewFetch(view, &rec);
1748     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1749
1750     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1751     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
1752
1753     MsiCloseHandle(rec);
1754
1755     r = MsiViewFetch(view, &rec);
1756     ok(r == ERROR_NO_MORE_ITEMS,
1757        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1758
1759     r = MsiViewClose(view);
1760     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1761
1762     MsiCloseHandle(view);
1763
1764     query = "SELECT * FROM `Table`";
1765     r = MsiDatabaseOpenView(hdb, query, &view);
1766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1767
1768     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1769     count = MsiRecordGetFieldCount(rec);
1770     ok(count == 6, "Expected 6, got %d\n", count);
1771     ok(check_record(rec, 1, "A"), "Expected A\n");
1772     ok(check_record(rec, 2, "B"), "Expected B\n");
1773     ok(check_record(rec, 3, "C"), "Expected C\n");
1774     ok(check_record(rec, 4, "D"), "Expected D\n");
1775     ok(check_record(rec, 5, "E"), "Expected E\n");
1776     ok(check_record(rec, 6, "F"), "Expected F\n");
1777     MsiCloseHandle(rec);
1778
1779     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1780     count = MsiRecordGetFieldCount(rec);
1781     ok(count == 6, "Expected 6, got %d\n", count);
1782     ok(check_record(rec, 1, "s72"), "Expected s72\n");
1783     ok(check_record(rec, 2, "s72"), "Expected s72\n");
1784     ok(check_record(rec, 3, "s72"), "Expected s72\n");
1785     ok(check_record(rec, 4, "s72"), "Expected s72\n");
1786     ok(check_record(rec, 5, "s72"), "Expected s72\n");
1787     ok(check_record(rec, 6, "s72"), "Expected s72\n");
1788     MsiCloseHandle(rec);
1789
1790     MsiViewClose(view);
1791     MsiCloseHandle(view);
1792
1793     query = "SELECT * FROM `Table`";
1794     r = MsiDatabaseOpenView(hdb, query, &view);
1795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1796
1797     r = MsiViewExecute(view, 0);
1798     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1799
1800     r = MsiViewFetch(view, &rec);
1801     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1802     ok(check_record(rec, 1, "a"), "Expected 'a'\n");
1803     ok(check_record(rec, 2, "b"), "Expected 'b'\n");
1804     ok(check_record(rec, 3, "c"), "Expected 'c'\n");
1805     ok(check_record(rec, 4, "d"), "Expected 'd'\n");
1806     ok(check_record(rec, 5, "e"), "Expected 'e'\n");
1807     ok(check_record(rec, 6, "f"), "Expected 'f'\n");
1808
1809     MsiCloseHandle(rec);
1810
1811     r = MsiViewFetch(view, &rec);
1812     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1813     ok(check_record(rec, 1, "g"), "Expected 'g'\n");
1814     ok(check_record(rec, 2, "h"), "Expected 'h'\n");
1815     ok(check_record(rec, 3, "i"), "Expected 'i'\n");
1816     ok(check_record(rec, 4, "j"), "Expected 'j'\n");
1817     ok(check_record(rec, 5, "k"), "Expected 'k'\n");
1818     ok(check_record(rec, 6, "l"), "Expected 'l'\n");
1819
1820     MsiCloseHandle(rec);
1821
1822     r = MsiViewFetch(view, &rec);
1823     ok(r == ERROR_NO_MORE_ITEMS,
1824        "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1825
1826     MsiViewClose(view);
1827     MsiCloseHandle(view);
1828     MsiCloseHandle(hdb);
1829     DeleteFileA(msifile);
1830 }
1831
1832 static void test_markers(void)
1833 {
1834     MSIHANDLE hdb, rec;
1835     LPCSTR query;
1836     UINT r;
1837
1838     hdb = create_db();
1839     ok( hdb, "failed to create db\n");
1840
1841     rec = MsiCreateRecord(3);
1842     MsiRecordSetString(rec, 1, "Table");
1843     MsiRecordSetString(rec, 2, "Apples");
1844     MsiRecordSetString(rec, 3, "Oranges");
1845
1846     /* try a legit create */
1847     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1848     r = run_query(hdb, 0, query);
1849     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1850     MsiCloseHandle(rec);
1851
1852     /* try table name as marker */
1853     rec = MsiCreateRecord(1);
1854     MsiRecordSetString(rec, 1, "Fable");
1855     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1856     r = run_query(hdb, rec, query);
1857     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1858
1859     /* verify that we just created a table called '?', not 'Fable' */
1860     r = try_query(hdb, "SELECT * from `Fable`");
1861     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1862
1863     r = try_query(hdb, "SELECT * from `?`");
1864     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1865
1866     /* try table name as marker without backticks */
1867     MsiRecordSetString(rec, 1, "Mable");
1868     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1869     r = run_query(hdb, rec, query);
1870     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1871
1872     /* try one column name as marker */
1873     MsiRecordSetString(rec, 1, "One");
1874     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1875     r = run_query(hdb, rec, query);
1876     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1877     MsiCloseHandle(rec);
1878
1879     /* try column names as markers */
1880     rec = MsiCreateRecord(2);
1881     MsiRecordSetString(rec, 1, "One");
1882     MsiRecordSetString(rec, 2, "Two");
1883     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1884     r = run_query(hdb, rec, query);
1885     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1886     MsiCloseHandle(rec);
1887
1888     /* try names with backticks */
1889     rec = MsiCreateRecord(3);
1890     MsiRecordSetString(rec, 1, "One");
1891     MsiRecordSetString(rec, 2, "Two");
1892     MsiRecordSetString(rec, 3, "One");
1893     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1894     r = run_query(hdb, rec, query);
1895     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1896
1897     /* try names with backticks, minus definitions */
1898     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1899     r = run_query(hdb, rec, query);
1900     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1901
1902     /* try names without backticks */
1903     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1904     r = run_query(hdb, rec, query);
1905     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1906     MsiCloseHandle(rec);
1907
1908     /* try one long marker */
1909     rec = MsiCreateRecord(1);
1910     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1911     query = "CREATE TABLE `Mable` ( ? )";
1912     r = run_query(hdb, rec, query);
1913     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1914     MsiCloseHandle(rec);
1915
1916     /* try all names as markers */
1917     rec = MsiCreateRecord(4);
1918     MsiRecordSetString(rec, 1, "Mable");
1919     MsiRecordSetString(rec, 2, "One");
1920     MsiRecordSetString(rec, 3, "Two");
1921     MsiRecordSetString(rec, 4, "One");
1922     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1923     r = run_query(hdb, rec, query);
1924     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1925     MsiCloseHandle(rec);
1926
1927     /* try a legit insert */
1928     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1929     r = run_query(hdb, 0, query);
1930     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1931
1932     r = try_query(hdb, "SELECT * from `Table`");
1933     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1934
1935     /* try values as markers */
1936     rec = MsiCreateRecord(2);
1937     MsiRecordSetInteger(rec, 1, 4);
1938     MsiRecordSetString(rec, 2, "hi");
1939     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1940     r = run_query(hdb, rec, query);
1941     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1942     MsiCloseHandle(rec);
1943
1944     /* try column names and values as markers */
1945     rec = MsiCreateRecord(4);
1946     MsiRecordSetString(rec, 1, "One");
1947     MsiRecordSetString(rec, 2, "Two");
1948     MsiRecordSetInteger(rec, 3, 5);
1949     MsiRecordSetString(rec, 4, "hi");
1950     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1951     r = run_query(hdb, rec, query);
1952     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1953     MsiCloseHandle(rec);
1954
1955     /* try column names as markers */
1956     rec = MsiCreateRecord(2);
1957     MsiRecordSetString(rec, 1, "One");
1958     MsiRecordSetString(rec, 2, "Two");
1959     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1960     r = run_query(hdb, rec, query);
1961     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1962     MsiCloseHandle(rec);
1963
1964     /* try table name as a marker */
1965     rec = MsiCreateRecord(1);
1966     MsiRecordSetString(rec, 1, "Table");
1967     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1968     r = run_query(hdb, rec, query);
1969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1970     MsiCloseHandle(rec);
1971
1972     /* try table name and values as markers */
1973     rec = MsiCreateRecord(3);
1974     MsiRecordSetString(rec, 1, "Table");
1975     MsiRecordSetInteger(rec, 2, 10);
1976     MsiRecordSetString(rec, 3, "haha");
1977     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1978     r = run_query(hdb, rec, query);
1979     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1980     MsiCloseHandle(rec);
1981
1982     /* try all markers */
1983     rec = MsiCreateRecord(5);
1984     MsiRecordSetString(rec, 1, "Table");
1985     MsiRecordSetString(rec, 1, "One");
1986     MsiRecordSetString(rec, 1, "Two");
1987     MsiRecordSetInteger(rec, 2, 10);
1988     MsiRecordSetString(rec, 3, "haha");
1989     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1990     r = run_query(hdb, rec, query);
1991     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1992     MsiCloseHandle(rec);
1993
1994     /* insert an integer as a string */
1995     rec = MsiCreateRecord(2);
1996     MsiRecordSetString(rec, 1, "11");
1997     MsiRecordSetString(rec, 2, "hi");
1998     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1999     r = run_query(hdb, rec, query);
2000     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2001     MsiCloseHandle(rec);
2002
2003     /* leave off the '' for the string */
2004     rec = MsiCreateRecord(2);
2005     MsiRecordSetInteger(rec, 1, 12);
2006     MsiRecordSetString(rec, 2, "hi");
2007     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
2008     r = run_query(hdb, rec, query);
2009     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2010     MsiCloseHandle(rec);
2011
2012     MsiCloseHandle(hdb);
2013     DeleteFileA(msifile);
2014 }
2015
2016 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
2017 static void test_handle_limit(void)
2018 {
2019     int i;
2020     MSIHANDLE hdb;
2021     MSIHANDLE hviews[MY_NVIEWS];
2022     UINT r;
2023
2024     /* create an empty db */
2025     hdb = create_db();
2026     ok( hdb, "failed to create db\n");
2027
2028     memset(hviews, 0, sizeof(hviews));
2029
2030     for (i=0; i<MY_NVIEWS; i++) {
2031         static char szQueryBuf[256] = "SELECT * from `_Tables`";
2032         hviews[i] = 0xdeadbeeb;
2033         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
2034         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
2035             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
2036             break;
2037     }
2038
2039     ok( i == MY_NVIEWS, "problem opening views\n");
2040
2041     for (i=0; i<MY_NVIEWS; i++) {
2042         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
2043             r = MsiCloseHandle(hviews[i]);
2044             if (r != ERROR_SUCCESS)
2045                 break;
2046         }
2047     }
2048
2049     ok( i == MY_NVIEWS, "problem closing views\n");
2050
2051     r = MsiCloseHandle(hdb);
2052     ok( r == ERROR_SUCCESS, "failed to close database\n");
2053 }
2054
2055 static void generate_transform(void)
2056 {
2057     MSIHANDLE hdb1, hdb2, hrec;
2058     LPCSTR query;
2059     UINT r;
2060
2061     /* start with two identical databases */
2062     CopyFile(msifile2, msifile, FALSE);
2063
2064     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb1 );
2065     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2066
2067     r = MsiDatabaseCommit( hdb1 );
2068     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2069
2070     r = MsiOpenDatabase(msifile2, MSIDBOPEN_READONLY, &hdb2 );
2071     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2072
2073     /* the transform between two identical database should be empty */
2074     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
2075     todo_wine {
2076     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
2077     }
2078
2079     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
2080     r = run_query(hdb1, 0, query);
2081     ok(r == ERROR_SUCCESS, "failed to add table\n");
2082
2083     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
2084     r = run_query(hdb1, 0, query);
2085     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
2086
2087     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
2088     r = run_query(hdb1, 0, query);
2089     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
2090
2091     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
2092     r = run_query(hdb1, 0, query);
2093     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2094
2095     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
2096     r = run_query(hdb1, 0, query);
2097     ok(r == ERROR_SUCCESS, "failed to delete row\n");
2098
2099     hrec = MsiCreateRecord(2);
2100     r = MsiRecordSetInteger(hrec, 1, 1);
2101     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2102
2103     write_file("testdata.bin", "naengmyon", 9);
2104     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2105     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2106
2107     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2108     r = run_query(hdb1, hrec, query);
2109     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2110
2111     MsiCloseHandle(hrec);
2112
2113     query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
2114     r = run_query(hdb1, 0, query);
2115     ok(r == ERROR_SUCCESS, "failed to add column\n");
2116
2117     query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
2118     r = run_query(hdb1, 0, query);
2119     ok(r == ERROR_SUCCESS, "failed to add column\n");
2120
2121     query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
2122     r = run_query(hdb1, 0, query);
2123     ok(r == ERROR_SUCCESS, "failed to modify row\n");
2124
2125     query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
2126             "`Value` CHAR(0) PRIMARY KEY `Property`)";
2127     r = run_query(hdb1, 0, query);
2128     ok(r == ERROR_SUCCESS, "failed to add property table\n");
2129
2130     query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
2131     r = run_query(hdb1, 0, query);
2132     ok(r == ERROR_SUCCESS, "failed to add property\n");
2133
2134     /* database needs to be committed */
2135     MsiDatabaseCommit(hdb1);
2136
2137     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
2138     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2139
2140     MsiCloseHandle( hdb1 );
2141     MsiCloseHandle( hdb2 );
2142
2143     DeleteFile("testdata.bin");
2144 }
2145
2146 /* data for generating a transform */
2147
2148 /* tables transform names - encoded as they would be in an msi database file */
2149 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
2150 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
2151 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
2152 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
2153 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
2154 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
2155 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
2156 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
2157 static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
2158
2159 /* data in each table */
2160 static const WCHAR data1[] = { /* AAR */
2161     0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
2162     0x0201, 0x0009, 0x8002,
2163 };
2164 static const WCHAR data2[] = { /* _Columns */
2165     0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
2166     0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
2167     0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
2168     0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
2169     0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
2170     0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
2171 };
2172 static const WCHAR data3[] = { /* _Tables */
2173     0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
2174     0x0101, 0x000a,
2175 };
2176 static const char data4[] = /* _StringData */
2177     "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
2178 static const WCHAR data5[] = { /* _StringPool */
2179 /*  len, refs */
2180     0,   0,    /* string 0 ''    */
2181     3,   2,    /* string 1 'MOO' */
2182     3,   1,    /* string 2 'COW' */
2183     3,   1,    /* string 3 'PIG' */
2184     1,   1,    /* string 4 'c'   */
2185     3,   3,    /* string 5 'AAR' */
2186     3,   1,    /* string 6 'CAR' */
2187     3,   1,    /* string 7 'BAR' */
2188     2,   1,    /* string 8 'vw'  */
2189     3,   1,    /* string 9 'bmw' */
2190     8,   4,    /* string 10 'Property' */
2191     5,   1,    /* string 11 'Value' */
2192     4,   1,    /* string 12 'prop' */
2193     3,   1,    /* string 13 'val' */
2194 };
2195 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
2196 static const WCHAR data6[] = { /* MOO */
2197     0x000a, 0x8001, 0x0004, 0x8005, /* update row */
2198     0x0000, 0x8003,         /* delete row */
2199 };
2200
2201 static const WCHAR data7[] = { /* BINARY */
2202     0x0201, 0x8001, 0x0001,
2203 };
2204
2205 static const char data8[] =  /* stream data for the BINARY table */
2206     "naengmyon";
2207
2208 static const WCHAR data9[] = { /* Property */
2209     0x0201, 0x000c, 0x000d,
2210 };
2211
2212 static const struct {
2213     LPCWSTR name;
2214     const void *data;
2215     DWORD size;
2216 } table_transform_data[] =
2217 {
2218     { name1, data1, sizeof data1 },
2219     { name2, data2, sizeof data2 },
2220     { name3, data3, sizeof data3 },
2221     { name4, data4, sizeof data4 - 1 },
2222     { name5, data5, sizeof data5 },
2223     { name6, data6, sizeof data6 },
2224     { name7, data7, sizeof data7 },
2225     { name8, data8, sizeof data8 - 1 },
2226     { name9, data9, sizeof data9 },
2227 };
2228
2229 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
2230
2231 static void generate_transform_manual(void)
2232 {
2233     IStorage *stg = NULL;
2234     IStream *stm;
2235     WCHAR name[0x20];
2236     HRESULT r;
2237     DWORD i, count;
2238     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
2239
2240     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
2241
2242     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
2243
2244     r = StgCreateDocfile(name, mode, 0, &stg);
2245     ok(r == S_OK, "failed to create storage\n");
2246     if (!stg)
2247         return;
2248
2249     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
2250     ok(r == S_OK, "failed to set storage type\n");
2251
2252     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
2253     {
2254         r = IStorage_CreateStream( stg, table_transform_data[i].name,
2255                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
2256         if (FAILED(r))
2257         {
2258             ok(0, "failed to create stream %08x\n", r);
2259             continue;
2260         }
2261
2262         r = IStream_Write( stm, table_transform_data[i].data,
2263                           table_transform_data[i].size, &count );
2264         if (FAILED(r) || count != table_transform_data[i].size)
2265             ok(0, "failed to write stream\n");
2266         IStream_Release(stm);
2267     }
2268
2269     IStorage_Release(stg);
2270 }
2271
2272 static UINT set_summary_info(MSIHANDLE hdb)
2273 {
2274     UINT res;
2275     MSIHANDLE suminfo;
2276
2277     /* build summary info */
2278     res = MsiGetSummaryInformation(hdb, NULL, 7, &suminfo);
2279     ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
2280
2281     res = MsiSummaryInfoSetProperty(suminfo,2, VT_LPSTR, 0,NULL,
2282                         "Installation Database");
2283     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2284
2285     res = MsiSummaryInfoSetProperty(suminfo,3, VT_LPSTR, 0,NULL,
2286                         "Installation Database");
2287     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2288
2289     res = MsiSummaryInfoSetProperty(suminfo,4, VT_LPSTR, 0,NULL,
2290                         "Wine Hackers");
2291     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2292
2293     res = MsiSummaryInfoSetProperty(suminfo,7, VT_LPSTR, 0,NULL,
2294                     ";1033");
2295     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2296
2297     res = MsiSummaryInfoSetProperty(suminfo,9, VT_LPSTR, 0,NULL,
2298                     "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
2299     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2300
2301     res = MsiSummaryInfoSetProperty(suminfo, 14, VT_I4, 100, NULL, NULL);
2302     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2303
2304     res = MsiSummaryInfoSetProperty(suminfo, 15, VT_I4, 0, NULL, NULL);
2305     ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
2306
2307     res = MsiSummaryInfoPersist(suminfo);
2308     ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
2309
2310     res = MsiCloseHandle( suminfo);
2311     ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
2312
2313     return res;
2314 }
2315
2316 static MSIHANDLE create_package_db(LPCSTR filename)
2317 {
2318     MSIHANDLE hdb = 0;
2319     UINT res;
2320
2321     DeleteFile(msifile);
2322
2323     /* create an empty database */
2324     res = MsiOpenDatabase(filename, MSIDBOPEN_CREATE, &hdb );
2325     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
2326     if( res != ERROR_SUCCESS )
2327         return hdb;
2328
2329     res = MsiDatabaseCommit( hdb );
2330     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
2331
2332     res = set_summary_info(hdb);
2333
2334     res = run_query( hdb, 0,
2335             "CREATE TABLE `Directory` ( "
2336             "`Directory` CHAR(255) NOT NULL, "
2337             "`Directory_Parent` CHAR(255), "
2338             "`DefaultDir` CHAR(255) NOT NULL "
2339             "PRIMARY KEY `Directory`)" );
2340     ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
2341
2342     return hdb;
2343 }
2344
2345 static MSIHANDLE package_from_db(MSIHANDLE hdb)
2346 {
2347     UINT res;
2348     CHAR szPackage[10];
2349     MSIHANDLE hPackage;
2350
2351     sprintf(szPackage,"#%li",hdb);
2352     res = MsiOpenPackage(szPackage,&hPackage);
2353     if (res != ERROR_SUCCESS)
2354         return 0;
2355
2356     res = MsiCloseHandle(hdb);
2357     if (res != ERROR_SUCCESS)
2358         return 0;
2359
2360     return hPackage;
2361 }
2362
2363 static void test_try_transform(void)
2364 {
2365     MSIHANDLE hdb, hview, hrec, hpkg;
2366     LPCSTR query;
2367     UINT r;
2368     DWORD sz;
2369     char buffer[MAX_PATH];
2370
2371     DeleteFile(msifile);
2372     DeleteFile(mstfile);
2373
2374     /* create the database */
2375     hdb = create_package_db(msifile);
2376     ok(hdb, "Failed to create package db\n");
2377
2378     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
2379     r = run_query(hdb, 0, query);
2380     ok(r == ERROR_SUCCESS, "failed to add table\n");
2381
2382     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
2383     r = run_query(hdb, 0, query);
2384     ok(r == ERROR_SUCCESS, "failed to add row\n");
2385
2386     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
2387     r = run_query(hdb, 0, query);
2388     ok(r == ERROR_SUCCESS, "failed to add row\n");
2389
2390     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
2391     r = run_query(hdb, 0, query);
2392     ok(r == ERROR_SUCCESS, "failed to add row\n");
2393
2394     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
2395     r = run_query(hdb, 0, query);
2396     ok(r == ERROR_SUCCESS, "failed to add table\n");
2397
2398     hrec = MsiCreateRecord(2);
2399     r = MsiRecordSetInteger(hrec, 1, 2);
2400     ok(r == ERROR_SUCCESS, "failed to set integer\n");
2401
2402     write_file("testdata.bin", "lamyon", 6);
2403     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
2404     ok(r == ERROR_SUCCESS, "failed to set stream\n");
2405
2406     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
2407     r = run_query(hdb, hrec, query);
2408     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
2409
2410     MsiCloseHandle(hrec);
2411
2412     r = MsiDatabaseCommit( hdb );
2413     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
2414
2415     MsiCloseHandle( hdb );
2416     DeleteFileA("testdata.bin");
2417
2418     /*
2419      * Both these generate an equivalent transform,
2420      *  but the first doesn't work in Wine yet
2421      *  because MsiDatabaseGenerateTransform is unimplemented.
2422      */
2423     if (0)
2424         generate_transform();
2425     else
2426         generate_transform_manual();
2427
2428     r = MsiOpenDatabase(msifile, MSIDBOPEN_DIRECT, &hdb );
2429     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2430
2431     r = MsiDatabaseApplyTransform( hdb, mstfile, 0 );
2432     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2433
2434     MsiDatabaseCommit( hdb );
2435
2436     /* check new values */
2437     hrec = 0;
2438     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
2439     r = do_query(hdb, query, &hrec);
2440     ok(r == ERROR_SUCCESS, "select query failed\n");
2441     MsiCloseHandle(hrec);
2442
2443     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
2444     hrec = 0;
2445     r = do_query(hdb, query, &hrec);
2446     ok(r == ERROR_SUCCESS, "select query failed\n");
2447     MsiCloseHandle(hrec);
2448
2449     /* check updated values */
2450     hrec = 0;
2451     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
2452     r = do_query(hdb, query, &hrec);
2453     ok(r == ERROR_SUCCESS, "select query failed\n");
2454     MsiCloseHandle(hrec);
2455
2456     /* check unchanged value */
2457     hrec = 0;
2458     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
2459     r = do_query(hdb, query, &hrec);
2460     ok(r == ERROR_SUCCESS, "select query failed\n");
2461     MsiCloseHandle(hrec);
2462
2463     /* check deleted value */
2464     hrec = 0;
2465     query = "select * from `MOO` where `NOO` = 3";
2466     r = do_query(hdb, query, &hrec);
2467     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
2468     if (hrec) MsiCloseHandle(hrec);
2469
2470     /* check added stream */
2471     hrec = 0;
2472     query = "select `BLOB` from `BINARY` where `ID` = 1";
2473     r = do_query(hdb, query, &hrec);
2474     ok(r == ERROR_SUCCESS, "select query failed\n");
2475
2476     /* check the contents of the stream */
2477     sz = sizeof buffer;
2478     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
2479     ok(r == ERROR_SUCCESS, "read stream failed\n");
2480     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
2481     ok(sz == 9, "stream data was wrong size\n");
2482     if (hrec) MsiCloseHandle(hrec);
2483
2484     /* check the validity of the table with a deleted row */
2485     hrec = 0;
2486     query = "select * from `MOO`";
2487     r = MsiDatabaseOpenView(hdb, query, &hview);
2488     ok(r == ERROR_SUCCESS, "open view failed\n");
2489
2490     r = MsiViewExecute(hview, 0);
2491     ok(r == ERROR_SUCCESS, "view execute failed\n");
2492
2493     r = MsiViewFetch(hview, &hrec);
2494     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2495
2496     r = MsiRecordGetInteger(hrec, 1);
2497     ok(r == 1, "Expected 1, got %d\n", r);
2498
2499     sz = sizeof buffer;
2500     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2501     ok(r == ERROR_SUCCESS, "record get string failed\n");
2502     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
2503
2504     r = MsiRecordGetInteger(hrec, 3);
2505     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2506
2507     r = MsiRecordGetInteger(hrec, 4);
2508     ok(r == 5, "Expected 5, got %d\n", r);
2509
2510     MsiCloseHandle(hrec);
2511
2512     r = MsiViewFetch(hview, &hrec);
2513     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2514
2515     r = MsiRecordGetInteger(hrec, 1);
2516     ok(r == 2, "Expected 2, got %d\n", r);
2517
2518     sz = sizeof buffer;
2519     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2520     ok(r == ERROR_SUCCESS, "record get string failed\n");
2521     ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
2522
2523     r = MsiRecordGetInteger(hrec, 3);
2524     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2525
2526     r = MsiRecordGetInteger(hrec, 4);
2527     ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
2528
2529     MsiCloseHandle(hrec);
2530
2531     r = MsiViewFetch(hview, &hrec);
2532     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
2533
2534     MsiCloseHandle(hrec);
2535     MsiCloseHandle(hview);
2536
2537     /* check that the property was added */
2538     hpkg = package_from_db(hdb);
2539     ok(hpkg != 0, "Expected non-NULL hpkg\n");
2540
2541     sz = MAX_PATH;
2542     r = MsiGetProperty(hpkg, "prop", buffer, &sz);
2543     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2544     ok(!lstrcmp(buffer, "val"), "Expected val, got %s\n", buffer);
2545
2546     MsiCloseHandle(hpkg);
2547     MsiCloseHandle(hdb);
2548
2549     DeleteFile(msifile);
2550     DeleteFile(mstfile);
2551 }
2552
2553 struct join_res
2554 {
2555     const CHAR one[MAX_PATH];
2556     const CHAR two[MAX_PATH];
2557 };
2558
2559 struct join_res_4col
2560 {
2561     const CHAR one[MAX_PATH];
2562     const CHAR two[MAX_PATH];
2563     const CHAR three[MAX_PATH];
2564     const CHAR four[MAX_PATH];
2565 };
2566
2567 struct join_res_uint
2568 {
2569     UINT one;
2570     UINT two;
2571     UINT three;
2572     UINT four;
2573     UINT five;
2574     UINT six;
2575 };
2576
2577 static const struct join_res join_res_first[] =
2578 {
2579     { "alveolar", "procerus" },
2580     { "septum", "procerus" },
2581     { "septum", "nasalis" },
2582     { "ramus", "nasalis" },
2583     { "malar", "mentalis" },
2584 };
2585
2586 static const struct join_res join_res_second[] =
2587 {
2588     { "nasal", "septum" },
2589     { "mandible", "ramus" },
2590 };
2591
2592 static const struct join_res join_res_third[] =
2593 {
2594     { "msvcp.dll", "abcdefgh" },
2595     { "msvcr.dll", "ijklmnop" },
2596 };
2597
2598 static const struct join_res join_res_fourth[] =
2599 {
2600     { "msvcp.dll.01234", "single.dll.31415" },
2601 };
2602
2603 static const struct join_res join_res_fifth[] =
2604 {
2605     { "malar", "procerus" },
2606 };
2607
2608 static const struct join_res join_res_sixth[] =
2609 {
2610     { "malar", "procerus" },
2611     { "malar", "procerus" },
2612     { "malar", "nasalis" },
2613     { "malar", "nasalis" },
2614     { "malar", "nasalis" },
2615     { "malar", "mentalis" },
2616 };
2617
2618 static const struct join_res join_res_seventh[] =
2619 {
2620     { "malar", "nasalis" },
2621     { "malar", "nasalis" },
2622     { "malar", "nasalis" },
2623 };
2624
2625 static const struct join_res_4col join_res_eighth[] =
2626 {
2627     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
2628     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
2629     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
2630     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
2631     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
2632     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
2633 };
2634
2635 static const struct join_res_uint join_res_ninth[] =
2636 {
2637     { 1, 2, 3, 4, 7, 8 },
2638     { 1, 2, 5, 6, 7, 8 },
2639     { 1, 2, 3, 4, 9, 10 },
2640     { 1, 2, 5, 6, 9, 10 },
2641     { 1, 2, 3, 4, 11, 12 },
2642     { 1, 2, 5, 6, 11, 12 },
2643 };
2644
2645 static void test_join(void)
2646 {
2647     MSIHANDLE hdb, hview, hrec;
2648     LPCSTR query;
2649     CHAR buf[MAX_PATH];
2650     UINT r, count;
2651     DWORD size, i;
2652     BOOL data_correct;
2653
2654     hdb = create_db();
2655     ok( hdb, "failed to create db\n");
2656
2657     r = create_component_table( hdb );
2658     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
2659
2660     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
2661     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2662
2663     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
2664     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2665
2666     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
2667     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2668
2669     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
2670     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2671
2672     r = create_feature_components_table( hdb );
2673     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
2674
2675     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
2676     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2677
2678     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
2679     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2680
2681     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
2682     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2683
2684     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
2685     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2686
2687     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
2688     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2689
2690     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
2691     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2692
2693     r = create_std_dlls_table( hdb );
2694     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
2695
2696     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
2697     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2698
2699     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
2700     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2701
2702     r = create_binary_table( hdb );
2703     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
2704
2705     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
2706     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2707
2708     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
2709     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2710
2711     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
2712     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2713
2714     query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
2715     r = run_query( hdb, 0, query);
2716     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2717
2718     query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
2719     r = run_query( hdb, 0, query);
2720     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2721
2722     query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
2723     r = run_query( hdb, 0, query);
2724     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2725
2726     query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
2727     r = run_query( hdb, 0, query);
2728     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2729
2730     query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
2731     r = run_query( hdb, 0, query);
2732     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2733
2734     query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
2735     r = run_query( hdb, 0, query);
2736     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2737
2738     query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
2739     r = run_query( hdb, 0, query);
2740     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2741
2742     query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
2743     r = run_query( hdb, 0, query);
2744     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2745
2746     query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
2747     r = run_query( hdb, 0, query);
2748     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2749
2750     query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
2751     r = run_query( hdb, 0, query);
2752     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2753
2754     query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
2755     r = run_query( hdb, 0, query);
2756     ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
2757
2758     query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
2759     r = run_query( hdb, 0, query);
2760     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2761
2762     query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
2763     r = run_query( hdb, 0, query);
2764     ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
2765
2766     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2767             "FROM `Component`, `FeatureComponents` "
2768             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
2769             "ORDER BY `Feature_`";
2770     r = MsiDatabaseOpenView(hdb, query, &hview);
2771     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2772
2773     r = MsiViewExecute(hview, 0);
2774     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2775
2776     i = 0;
2777     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2778     {
2779         count = MsiRecordGetFieldCount( hrec );
2780         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2781
2782         size = MAX_PATH;
2783         r = MsiRecordGetString( hrec, 1, buf, &size );
2784         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2785         ok( !lstrcmp( buf, join_res_first[i].one ),
2786             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
2787
2788         size = MAX_PATH;
2789         r = MsiRecordGetString( hrec, 2, buf, &size );
2790         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2791         ok( !lstrcmp( buf, join_res_first[i].two ),
2792             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
2793
2794         i++;
2795         MsiCloseHandle(hrec);
2796     }
2797
2798     ok( i == 5, "Expected 5 rows, got %d\n", i );
2799     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2800
2801     MsiViewClose(hview);
2802     MsiCloseHandle(hview);
2803
2804     /* try a join without a WHERE condition */
2805     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2806             "FROM `Component`, `FeatureComponents` ";
2807     r = MsiDatabaseOpenView(hdb, query, &hview);
2808     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2809
2810     r = MsiViewExecute(hview, 0);
2811     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2812
2813     i = 0;
2814     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2815     {
2816         i++;
2817         MsiCloseHandle(hrec);
2818     }
2819     ok( i == 24, "Expected 24 rows, got %d\n", i );
2820
2821     MsiViewClose(hview);
2822     MsiCloseHandle(hview);
2823
2824     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
2825             "WHERE FeatureComponents.Component_=Component.Component "
2826             "AND (Feature_='nasalis') ORDER BY Feature_";
2827     r = MsiDatabaseOpenView(hdb, query, &hview);
2828     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2829
2830     r = MsiViewExecute(hview, 0);
2831     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2832
2833     i = 0;
2834     data_correct = TRUE;
2835     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2836     {
2837         count = MsiRecordGetFieldCount( hrec );
2838         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2839
2840         size = MAX_PATH;
2841         r = MsiRecordGetString( hrec, 1, buf, &size );
2842         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2843         if( lstrcmp( buf, join_res_second[i].one ))
2844             data_correct = FALSE;
2845
2846         size = MAX_PATH;
2847         r = MsiRecordGetString( hrec, 2, buf, &size );
2848         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2849         if( lstrcmp( buf, join_res_second[i].two ))
2850             data_correct = FALSE;
2851
2852         i++;
2853         MsiCloseHandle(hrec);
2854     }
2855
2856     ok( data_correct, "data returned in the wrong order\n");
2857
2858     ok( i == 2, "Expected 2 rows, got %d\n", i );
2859     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2860
2861     MsiViewClose(hview);
2862     MsiCloseHandle(hview);
2863
2864     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2865             "FROM `StdDlls`, `Binary` "
2866             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
2867             "ORDER BY `File`";
2868     r = MsiDatabaseOpenView(hdb, query, &hview);
2869     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2870
2871     r = MsiViewExecute(hview, 0);
2872     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2873
2874     i = 0;
2875     data_correct = TRUE;
2876     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2877     {
2878         count = MsiRecordGetFieldCount( hrec );
2879         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2880
2881         size = MAX_PATH;
2882         r = MsiRecordGetString( hrec, 1, buf, &size );
2883         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2884         if( lstrcmp( buf, join_res_third[i].one ) )
2885             data_correct = FALSE;
2886
2887         size = MAX_PATH;
2888         r = MsiRecordGetString( hrec, 2, buf, &size );
2889         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2890         if( lstrcmp( buf, join_res_third[i].two ) )
2891             data_correct = FALSE;
2892
2893         i++;
2894         MsiCloseHandle(hrec);
2895     }
2896     ok( data_correct, "data returned in the wrong order\n");
2897
2898     ok( i == 2, "Expected 2 rows, got %d\n", i );
2899
2900     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2901
2902     MsiViewClose(hview);
2903     MsiCloseHandle(hview);
2904
2905     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
2906             "FROM `StdDlls`, `Binary` "
2907             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
2908             "ORDER BY `Name`";
2909     r = MsiDatabaseOpenView(hdb, query, &hview);
2910     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2911
2912     r = MsiViewExecute(hview, 0);
2913     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2914
2915     i = 0;
2916     data_correct = TRUE;
2917     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2918     {
2919         count = MsiRecordGetFieldCount( hrec );
2920         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2921
2922         size = MAX_PATH;
2923         r = MsiRecordGetString( hrec, 1, buf, &size );
2924         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2925         if( lstrcmp( buf, join_res_fourth[i].one ))
2926             data_correct = FALSE;
2927
2928         size = MAX_PATH;
2929         r = MsiRecordGetString( hrec, 2, buf, &size );
2930         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2931         if( lstrcmp( buf, join_res_fourth[i].two ))
2932             data_correct = FALSE;
2933
2934         i++;
2935         MsiCloseHandle(hrec);
2936     }
2937     ok( data_correct, "data returned in the wrong order\n");
2938
2939     ok( i == 1, "Expected 1 rows, got %d\n", i );
2940     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2941
2942     MsiViewClose(hview);
2943     MsiCloseHandle(hview);
2944
2945     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2946             "FROM `Component`, `FeatureComponents` "
2947             "WHERE `Component`.`Component` = 'zygomatic' "
2948             "AND `FeatureComponents`.`Component_` = 'maxilla' "
2949             "ORDER BY `Feature_`";
2950     r = MsiDatabaseOpenView(hdb, query, &hview);
2951     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2952
2953     r = MsiViewExecute(hview, 0);
2954     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2955
2956     i = 0;
2957     data_correct = TRUE;
2958     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2959     {
2960         count = MsiRecordGetFieldCount( hrec );
2961         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2962
2963         size = MAX_PATH;
2964         r = MsiRecordGetString( hrec, 1, buf, &size );
2965         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2966         if( lstrcmp( buf, join_res_fifth[i].one ))
2967             data_correct = FALSE;
2968
2969         size = MAX_PATH;
2970         r = MsiRecordGetString( hrec, 2, buf, &size );
2971         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2972         if( lstrcmp( buf, join_res_fifth[i].two ))
2973             data_correct = FALSE;
2974
2975         i++;
2976         MsiCloseHandle(hrec);
2977     }
2978     ok( data_correct, "data returned in the wrong order\n");
2979
2980     ok( i == 1, "Expected 1 rows, got %d\n", i );
2981     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2982
2983     MsiViewClose(hview);
2984     MsiCloseHandle(hview);
2985
2986     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2987             "FROM `Component`, `FeatureComponents` "
2988             "WHERE `Component` = 'zygomatic' "
2989             "ORDER BY `Feature_`";
2990     r = MsiDatabaseOpenView(hdb, query, &hview);
2991     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2992
2993     r = MsiViewExecute(hview, 0);
2994     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2995
2996     i = 0;
2997     data_correct = TRUE;
2998     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2999     {
3000         count = MsiRecordGetFieldCount( hrec );
3001         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3002
3003         size = MAX_PATH;
3004         r = MsiRecordGetString( hrec, 1, buf, &size );
3005         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3006         if( lstrcmp( buf, join_res_sixth[i].one ))
3007             data_correct = FALSE;
3008
3009         size = MAX_PATH;
3010         r = MsiRecordGetString( hrec, 2, buf, &size );
3011         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3012         if( lstrcmp( buf, join_res_sixth[i].two ))
3013             data_correct = FALSE;
3014
3015         i++;
3016         MsiCloseHandle(hrec);
3017     }
3018     ok( data_correct, "data returned in the wrong order\n");
3019
3020     ok( i == 6, "Expected 6 rows, got %d\n", i );
3021     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3022
3023     MsiViewClose(hview);
3024     MsiCloseHandle(hview);
3025
3026     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
3027             "FROM `Component`, `FeatureComponents` "
3028             "WHERE `Component` = 'zygomatic' "
3029             "AND `Feature_` = 'nasalis' "
3030             "ORDER BY `Feature_`";
3031     r = MsiDatabaseOpenView(hdb, query, &hview);
3032     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3033
3034     r = MsiViewExecute(hview, 0);
3035     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3036
3037     i = 0;
3038     data_correct = TRUE;
3039     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3040     {
3041         count = MsiRecordGetFieldCount( hrec );
3042         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3043
3044         size = MAX_PATH;
3045         r = MsiRecordGetString( hrec, 1, buf, &size );
3046         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3047         if( lstrcmp( buf, join_res_seventh[i].one ))
3048             data_correct = FALSE;
3049
3050         size = MAX_PATH;
3051         r = MsiRecordGetString( hrec, 2, buf, &size );
3052         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3053         if( lstrcmp( buf, join_res_seventh[i].two ))
3054             data_correct = FALSE;
3055
3056         i++;
3057         MsiCloseHandle(hrec);
3058     }
3059
3060     ok( data_correct, "data returned in the wrong order\n");
3061     ok( i == 3, "Expected 3 rows, got %d\n", i );
3062     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3063
3064     MsiViewClose(hview);
3065     MsiCloseHandle(hview);
3066
3067     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
3068             "FROM `StdDlls`, `Binary` ";
3069     r = MsiDatabaseOpenView(hdb, query, &hview);
3070     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3071
3072     r = MsiViewExecute(hview, 0);
3073     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3074
3075     i = 0;
3076     data_correct = TRUE;
3077     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3078     {
3079         count = MsiRecordGetFieldCount( hrec );
3080         ok( count == 2, "Expected 2 record fields, got %d\n", count );
3081
3082         size = MAX_PATH;
3083         r = MsiRecordGetString( hrec, 1, buf, &size );
3084         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3085         if( lstrcmp( buf, join_res_eighth[i].one ))
3086             data_correct = FALSE;
3087
3088         size = MAX_PATH;
3089         r = MsiRecordGetString( hrec, 2, buf, &size );
3090         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3091         if( lstrcmp( buf, join_res_eighth[i].four ))
3092             data_correct = FALSE;
3093
3094         i++;
3095         MsiCloseHandle(hrec);
3096     }
3097
3098     ok( data_correct, "data returned in the wrong order\n");
3099     ok( i == 6, "Expected 6 rows, got %d\n", i );
3100     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3101
3102     MsiViewClose(hview);
3103     MsiCloseHandle(hview);
3104
3105     query = "SELECT * FROM `StdDlls`, `Binary` ";
3106     r = MsiDatabaseOpenView(hdb, query, &hview);
3107     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3108
3109     r = MsiViewExecute(hview, 0);
3110     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3111
3112     i = 0;
3113     data_correct = TRUE;
3114     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3115     {
3116         count = MsiRecordGetFieldCount( hrec );
3117         ok( count == 4, "Expected 4 record fields, got %d\n", count );
3118
3119         size = MAX_PATH;
3120         r = MsiRecordGetString( hrec, 1, buf, &size );
3121         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3122         if( lstrcmp( buf, join_res_eighth[i].one ))
3123             data_correct = FALSE;
3124
3125         size = MAX_PATH;
3126         r = MsiRecordGetString( hrec, 2, buf, &size );
3127         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3128         if( lstrcmp( buf, join_res_eighth[i].two ))
3129             data_correct = FALSE;
3130
3131         size = MAX_PATH;
3132         r = MsiRecordGetString( hrec, 3, buf, &size );
3133         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3134         if( lstrcmp( buf, join_res_eighth[i].three ))
3135             data_correct = FALSE;
3136
3137         size = MAX_PATH;
3138         r = MsiRecordGetString( hrec, 4, buf, &size );
3139         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
3140         if( lstrcmp( buf, join_res_eighth[i].four ))
3141             data_correct = FALSE;
3142
3143         i++;
3144         MsiCloseHandle(hrec);
3145     }
3146     ok( data_correct, "data returned in the wrong order\n");
3147
3148     ok( i == 6, "Expected 6 rows, got %d\n", i );
3149     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3150
3151     MsiViewClose(hview);
3152     MsiCloseHandle(hview);
3153
3154     query = "SELECT * FROM `One`, `Two`, `Three` ";
3155     r = MsiDatabaseOpenView(hdb, query, &hview);
3156     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3157
3158     r = MsiViewExecute(hview, 0);
3159     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3160
3161     i = 0;
3162     data_correct = TRUE;
3163     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
3164     {
3165         count = MsiRecordGetFieldCount( hrec );
3166         ok( count == 6, "Expected 6 record fields, got %d\n", count );
3167
3168         r = MsiRecordGetInteger( hrec, 1 );
3169         if( r != join_res_ninth[i].one )
3170             data_correct = FALSE;
3171
3172         r = MsiRecordGetInteger( hrec, 2 );
3173         if( r != join_res_ninth[i].two )
3174             data_correct = FALSE;
3175
3176         r = MsiRecordGetInteger( hrec, 3 );
3177         if( r != join_res_ninth[i].three )
3178             data_correct = FALSE;
3179
3180         r = MsiRecordGetInteger( hrec, 4 );
3181         if( r != join_res_ninth[i].four )
3182             data_correct = FALSE;
3183
3184         r = MsiRecordGetInteger( hrec, 5 );
3185         if( r != join_res_ninth[i].five )
3186             data_correct = FALSE;
3187
3188         r = MsiRecordGetInteger( hrec, 6);
3189         if( r != join_res_ninth[i].six )
3190             data_correct = FALSE;
3191
3192         i++;
3193         MsiCloseHandle(hrec);
3194     }
3195     ok( data_correct, "data returned in the wrong order\n");
3196
3197     ok( i == 6, "Expected 6 rows, got %d\n", i );
3198     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
3199
3200     MsiViewClose(hview);
3201     MsiCloseHandle(hview);
3202
3203     query = "SELECT * FROM `Four`, `Five`";
3204     r = MsiDatabaseOpenView(hdb, query, &hview);
3205     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
3206
3207     r = MsiViewExecute(hview, 0);
3208     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
3209
3210     r = MsiViewFetch(hview, &hrec);
3211     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3212
3213     MsiViewClose(hview);
3214     MsiCloseHandle(hview);
3215
3216     query = "SELECT * FROM `Nonexistent`, `One`";
3217     r = MsiDatabaseOpenView(hdb, query, &hview);
3218     ok( r == ERROR_BAD_QUERY_SYNTAX,
3219         "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
3220
3221     MsiCloseHandle(hdb);
3222     DeleteFile(msifile);
3223 }
3224
3225 static void test_temporary_table(void)
3226 {
3227     MSICONDITION cond;
3228     MSIHANDLE hdb = 0, view = 0, rec;
3229     const char *query;
3230     UINT r;
3231     char buf[0x10];
3232     DWORD sz;
3233
3234     cond = MsiDatabaseIsTablePersistent(0, NULL);
3235     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3236
3237     hdb = create_db();
3238     ok( hdb, "failed to create db\n");
3239
3240     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
3241     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
3242
3243     todo_wine {
3244     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
3245     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3246
3247     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
3248     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3249     }
3250
3251     cond = MsiDatabaseIsTablePersistent(hdb, "_Storages");
3252     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3253
3254     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
3255     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3256
3257     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
3258     r = run_query(hdb, 0, query);
3259     ok(r == ERROR_SUCCESS, "failed to add table\n");
3260
3261     cond = MsiDatabaseIsTablePersistent(hdb, "P");
3262     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3263
3264     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
3265     r = run_query(hdb, 0, query);
3266     ok(r == ERROR_SUCCESS, "failed to add table\n");
3267
3268     cond = MsiDatabaseIsTablePersistent(hdb, "P2");
3269     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3270
3271     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
3272     r = run_query(hdb, 0, query);
3273     ok(r == ERROR_SUCCESS, "failed to add table\n");
3274
3275     cond = MsiDatabaseIsTablePersistent(hdb, "T");
3276     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
3277
3278     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3279     r = run_query(hdb, 0, query);
3280     ok(r == ERROR_SUCCESS, "failed to add table\n");
3281
3282     todo_wine {
3283     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
3284     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3285     }
3286
3287     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
3288     r = run_query(hdb, 0, query);
3289     ok(r == ERROR_SUCCESS, "failed to add table\n");
3290
3291     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
3292     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
3293
3294     todo_wine {
3295     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
3296     r = run_query(hdb, 0, query);
3297     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
3298
3299     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
3300     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
3301     }
3302
3303     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
3304     r = run_query(hdb, 0, query);
3305     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
3306
3307     query = "select * from `T`";
3308     r = MsiDatabaseOpenView(hdb, query, &view);
3309     ok(r == ERROR_SUCCESS, "failed to query table\n");
3310     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
3311     ok(r == ERROR_SUCCESS, "failed to get column info\n");
3312
3313     sz = sizeof buf;
3314     r = MsiRecordGetString(rec, 1, buf, &sz);
3315     ok(r == ERROR_SUCCESS, "failed to get string\n");
3316     todo_wine ok( 0 == strcmp("G255", buf), "wrong column type\n");
3317
3318     sz = sizeof buf;
3319     r = MsiRecordGetString(rec, 2, buf, &sz);
3320     ok(r == ERROR_SUCCESS, "failed to get string\n");
3321     todo_wine ok( 0 == strcmp("j2", buf), "wrong column type\n");
3322
3323     MsiCloseHandle( rec );
3324     MsiCloseHandle( view );
3325
3326     /* query the table data */
3327     rec = 0;
3328     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
3329     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
3330     MsiCloseHandle( rec );
3331
3332     /* query the column data */
3333     rec = 0;
3334     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
3335     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3336     if (rec) MsiCloseHandle( rec );
3337
3338     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
3339     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
3340     if (rec) MsiCloseHandle( rec );
3341
3342     MsiCloseHandle( hdb );
3343
3344     DeleteFile(msifile);
3345 }
3346
3347 static void test_alter(void)
3348 {
3349     MSICONDITION cond;
3350     MSIHANDLE hdb = 0;
3351     const char *query;
3352     UINT r;
3353
3354     hdb = create_db();
3355     ok( hdb, "failed to create db\n");
3356
3357     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
3358     r = run_query(hdb, 0, query);
3359     ok(r == ERROR_SUCCESS, "failed to add table\n");
3360
3361     cond = MsiDatabaseIsTablePersistent(hdb, "T");
3362     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
3363
3364     query = "ALTER TABLE `T` HOLD";
3365     r = run_query(hdb, 0, query);
3366     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
3367
3368     query = "ALTER TABLE `T` FREE";
3369     r = run_query(hdb, 0, query);
3370     ok(r == ERROR_SUCCESS, "failed to free table\n");
3371
3372     query = "ALTER TABLE `T` FREE";
3373     r = run_query(hdb, 0, query);
3374     ok(r == ERROR_SUCCESS, "failed to free table\n");
3375
3376     query = "ALTER TABLE `T` FREE";
3377     r = run_query(hdb, 0, query);
3378     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
3379
3380     query = "ALTER TABLE `T` HOLD";
3381     r = run_query(hdb, 0, query);
3382     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
3383
3384     /* table T is removed */
3385     query = "SELECT * FROM `T`";
3386     r = run_query(hdb, 0, query);
3387     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3388
3389     /* create the table again */
3390     query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
3391     r = run_query(hdb, 0, query);
3392     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3393
3394     /* up the ref count */
3395     query = "ALTER TABLE `U` HOLD";
3396     r = run_query(hdb, 0, query);
3397     ok(r == ERROR_SUCCESS, "failed to free table\n");
3398
3399     /* add column, no data type */
3400     query = "ALTER TABLE `U` ADD `C`";
3401     r = run_query(hdb, 0, query);
3402     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3403
3404     query = "ALTER TABLE `U` ADD `C` INTEGER";
3405     r = run_query(hdb, 0, query);
3406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3407
3408     /* add column C again */
3409     query = "ALTER TABLE `U` ADD `C` INTEGER";
3410     r = run_query(hdb, 0, query);
3411     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3412
3413     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
3414     r = run_query(hdb, 0, query);
3415     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3416
3417     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
3418     r = run_query(hdb, 0, query);
3419     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3420
3421     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
3422     r = run_query(hdb, 0, query);
3423     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3424
3425     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
3426     r = run_query(hdb, 0, query);
3427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3428
3429     query = "SELECT * FROM `U` WHERE `D` = 8";
3430     r = run_query(hdb, 0, query);
3431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3432
3433     query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
3434     r = run_query(hdb, 0, query);
3435     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3436
3437     query = "ALTER COLUMN `D` FREE";
3438     r = run_query(hdb, 0, query);
3439     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3440
3441     /* drop the ref count */
3442     query = "ALTER TABLE `U` FREE";
3443     r = run_query(hdb, 0, query);
3444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3445
3446     /* table is not empty */
3447     query = "SELECT * FROM `U`";
3448     r = run_query(hdb, 0, query);
3449     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3450
3451     /* column D is removed */
3452     query = "SELECT * FROM `U` WHERE `D` = 8";
3453     r = run_query(hdb, 0, query);
3454     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3455
3456     query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
3457     r = run_query(hdb, 0, query);
3458     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3459
3460     /* add the column again */
3461     query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
3462     r = run_query(hdb, 0, query);
3463     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3464
3465     /* up the ref count */
3466     query = "ALTER TABLE `U` HOLD";
3467     r = run_query(hdb, 0, query);
3468     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3469
3470     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
3471     r = run_query(hdb, 0, query);
3472     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3473
3474     query = "SELECT * FROM `U` WHERE `E` = 16";
3475     r = run_query(hdb, 0, query);
3476     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3477
3478     /* drop the ref count */
3479     query = "ALTER TABLE `U` FREE";
3480     r = run_query(hdb, 0, query);
3481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3482
3483     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
3484     r = run_query(hdb, 0, query);
3485     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3486
3487     query = "SELECT * FROM `U` WHERE `E` = 20";
3488     r = run_query(hdb, 0, query);
3489     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3490
3491     /* drop the ref count */
3492     query = "ALTER TABLE `U` FREE";
3493     r = run_query(hdb, 0, query);
3494     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3495
3496     /* table still exists */
3497     query = "SELECT * FROM `U`";
3498     r = run_query(hdb, 0, query);
3499     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3500
3501     /* col E is removed */
3502     query = "SELECT * FROM `U` WHERE `E` = 20";
3503     r = run_query(hdb, 0, query);
3504     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3505
3506     query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
3507     r = run_query(hdb, 0, query);
3508     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3509
3510     /* drop the ref count once more */
3511     query = "ALTER TABLE `U` FREE";
3512     r = run_query(hdb, 0, query);
3513     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3514
3515     /* table still exists */
3516     query = "SELECT * FROM `U`";
3517     r = run_query(hdb, 0, query);
3518     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3519
3520     MsiCloseHandle( hdb );
3521     DeleteFile(msifile);
3522 }
3523
3524 static void test_integers(void)
3525 {
3526     MSIHANDLE hdb = 0, view = 0, rec = 0;
3527     DWORD count, i;
3528     const char *query;
3529     UINT r;
3530
3531     /* just MsiOpenDatabase should not create a file */
3532     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3533     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3534
3535     /* create a table */
3536     query = "CREATE TABLE `integers` ( "
3537             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
3538             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
3539             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
3540             "PRIMARY KEY `one`)";
3541     r = MsiDatabaseOpenView(hdb, query, &view);
3542     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3543     r = MsiViewExecute(view, 0);
3544     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3545     r = MsiViewClose(view);
3546     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3547     r = MsiCloseHandle(view);
3548     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3549
3550     query = "SELECT * FROM `integers`";
3551     r = MsiDatabaseOpenView(hdb, query, &view);
3552     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3553
3554     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
3555     count = MsiRecordGetFieldCount(rec);
3556     ok(count == 8, "Expected 8, got %d\n", count);
3557     ok(check_record(rec, 1, "one"), "Expected one\n");
3558     ok(check_record(rec, 2, "two"), "Expected two\n");
3559     ok(check_record(rec, 3, "three"), "Expected three\n");
3560     ok(check_record(rec, 4, "four"), "Expected four\n");
3561     ok(check_record(rec, 5, "five"), "Expected five\n");
3562     ok(check_record(rec, 6, "six"), "Expected six\n");
3563     ok(check_record(rec, 7, "seven"), "Expected seven\n");
3564     ok(check_record(rec, 8, "eight"), "Expected eight\n");
3565     MsiCloseHandle(rec);
3566
3567     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
3568     count = MsiRecordGetFieldCount(rec);
3569     ok(count == 8, "Expected 8, got %d\n", count);
3570     ok(check_record(rec, 1, "I2"), "Expected I2\n");
3571     ok(check_record(rec, 2, "I2"), "Expected I2\n");
3572     ok(check_record(rec, 3, "I2"), "Expected I2\n");
3573     ok(check_record(rec, 4, "I4"), "Expected I4\n");
3574     ok(check_record(rec, 5, "i2"), "Expected i2\n");
3575     ok(check_record(rec, 6, "i2"), "Expected i2\n");
3576     ok(check_record(rec, 7, "i2"), "Expected i2\n");
3577     ok(check_record(rec, 8, "i4"), "Expected i4\n");
3578     MsiCloseHandle(rec);
3579
3580     MsiViewClose(view);
3581     MsiCloseHandle(view);
3582
3583     /* insert values into it, NULL where NOT NULL is specified */
3584     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
3585         "VALUES('', '', '', '', '', '', '', '')";
3586     r = MsiDatabaseOpenView(hdb, query, &view);
3587     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3588     r = MsiViewExecute(view, 0);
3589     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
3590
3591     MsiViewClose(view);
3592     MsiCloseHandle(view);
3593
3594     query = "SELECT * FROM `integers`";
3595     r = do_query(hdb, query, &rec);
3596     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3597
3598     r = MsiRecordGetFieldCount(rec);
3599     ok(r == -1, "record count wrong: %d\n", r);
3600
3601     MsiCloseHandle(rec);
3602
3603     /* insert legitimate values into it */
3604     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
3605         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
3606     r = MsiDatabaseOpenView(hdb, query, &view);
3607     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3608     r = MsiViewExecute(view, 0);
3609     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3610
3611     query = "SELECT * FROM `integers`";
3612     r = do_query(hdb, query, &rec);
3613     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3614
3615     r = MsiRecordGetFieldCount(rec);
3616     ok(r == 8, "record count wrong: %d\n", r);
3617
3618     i = MsiRecordGetInteger(rec, 1);
3619     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
3620     i = MsiRecordGetInteger(rec, 3);
3621     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
3622     i = MsiRecordGetInteger(rec, 2);
3623     ok(i == 2, "Expected 2, got %d\n", i);
3624     i = MsiRecordGetInteger(rec, 4);
3625     ok(i == 4, "Expected 4, got %d\n", i);
3626     i = MsiRecordGetInteger(rec, 5);
3627     ok(i == 5, "Expected 5, got %d\n", i);
3628     i = MsiRecordGetInteger(rec, 6);
3629     ok(i == 6, "Expected 6, got %d\n", i);
3630     i = MsiRecordGetInteger(rec, 7);
3631     ok(i == 7, "Expected 7, got %d\n", i);
3632     i = MsiRecordGetInteger(rec, 8);
3633     ok(i == 8, "Expected 8, got %d\n", i);
3634
3635     MsiCloseHandle(rec);
3636     MsiViewClose(view);
3637     MsiCloseHandle(view);
3638
3639     r = MsiDatabaseCommit(hdb);
3640     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
3641
3642     r = MsiCloseHandle(hdb);
3643     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3644
3645     r = DeleteFile(msifile);
3646     ok(r == TRUE, "file didn't exist after commit\n");
3647 }
3648
3649 static void test_update(void)
3650 {
3651     MSIHANDLE hdb = 0, view = 0, rec = 0;
3652     CHAR result[MAX_PATH];
3653     const char *query;
3654     DWORD size;
3655     UINT r;
3656
3657     /* just MsiOpenDatabase should not create a file */
3658     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3659     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3660
3661     /* create the Control table */
3662     query = "CREATE TABLE `Control` ( "
3663         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
3664         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
3665         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
3666         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
3667     r = MsiDatabaseOpenView(hdb, query, &view);
3668     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
3669     r = MsiViewExecute(view, 0);
3670     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
3671     r = MsiViewClose(view);
3672     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3673     r = MsiCloseHandle(view);
3674     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3675
3676     /* add a control */
3677     query = "INSERT INTO `Control` ( "
3678         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3679         "`Property`, `Text`, `Control_Next`, `Help` )"
3680         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
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     /* add a second control */
3691     query = "INSERT INTO `Control` ( "
3692         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3693         "`Property`, `Text`, `Control_Next`, `Help` )"
3694         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
3695     r = MsiDatabaseOpenView(hdb, query, &view);
3696     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3697     r = MsiViewExecute(view, 0);
3698     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3699     r = MsiViewClose(view);
3700     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3701     r = MsiCloseHandle(view);
3702     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3703
3704     /* add a third control */
3705     query = "INSERT INTO `Control` ( "
3706         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
3707         "`Property`, `Text`, `Control_Next`, `Help` )"
3708         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
3709     r = MsiDatabaseOpenView(hdb, query, &view);
3710     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3711     r = MsiViewExecute(view, 0);
3712     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3713     r = MsiViewClose(view);
3714     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3715     r = MsiCloseHandle(view);
3716     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3717
3718     /* bad table */
3719     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3720     r = MsiDatabaseOpenView(hdb, query, &view);
3721     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3722
3723     /* bad set column */
3724     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3725     r = MsiDatabaseOpenView(hdb, query, &view);
3726     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3727
3728     /* bad where condition */
3729     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
3730     r = MsiDatabaseOpenView(hdb, query, &view);
3731     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3732
3733     /* just the dialog_ specified */
3734     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3735     r = MsiDatabaseOpenView(hdb, query, &view);
3736     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3737     r = MsiViewExecute(view, 0);
3738     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3739     r = MsiViewClose(view);
3740     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3741     r = MsiCloseHandle(view);
3742     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3743
3744     /* check the modified text */
3745     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3746     r = MsiDatabaseOpenView(hdb, query, &view);
3747     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3748     r = MsiViewExecute(view, 0);
3749     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3750
3751     r = MsiViewFetch(view, &rec);
3752     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3753
3754     size = MAX_PATH;
3755     r = MsiRecordGetString(rec, 1, result, &size);
3756     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3757     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3758
3759     MsiCloseHandle(rec);
3760
3761     r = MsiViewFetch(view, &rec);
3762     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3763
3764     size = MAX_PATH;
3765     r = MsiRecordGetString(rec, 1, result, &size);
3766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3767     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3768
3769     MsiCloseHandle(rec);
3770
3771     r = MsiViewFetch(view, &rec);
3772     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3773
3774     r = MsiViewClose(view);
3775     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3776     r = MsiCloseHandle(view);
3777     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3778
3779     /* dialog_ and control specified */
3780     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
3781     r = MsiDatabaseOpenView(hdb, query, &view);
3782     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3783     r = MsiViewExecute(view, 0);
3784     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3785     r = MsiViewClose(view);
3786     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3787     r = MsiCloseHandle(view);
3788     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3789
3790     /* check the modified text */
3791     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3792     r = MsiDatabaseOpenView(hdb, query, &view);
3793     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3794     r = MsiViewExecute(view, 0);
3795     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3796
3797     r = MsiViewFetch(view, &rec);
3798     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3799
3800     size = MAX_PATH;
3801     r = MsiRecordGetString(rec, 1, result, &size);
3802     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3803     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3804
3805     MsiCloseHandle(rec);
3806
3807     r = MsiViewFetch(view, &rec);
3808     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3809
3810     size = MAX_PATH;
3811     r = MsiRecordGetString(rec, 1, result, &size);
3812     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3813     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3814
3815     MsiCloseHandle(rec);
3816
3817     r = MsiViewFetch(view, &rec);
3818     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3819
3820     r = MsiViewClose(view);
3821     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3822     r = MsiCloseHandle(view);
3823     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3824
3825     /* no where condition */
3826     query = "UPDATE `Control` SET `Text` = 'this is text'";
3827     r = MsiDatabaseOpenView(hdb, query, &view);
3828     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3829     r = MsiViewExecute(view, 0);
3830     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3831     r = MsiViewClose(view);
3832     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3833     r = MsiCloseHandle(view);
3834     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3835
3836     /* check the modified text */
3837     query = "SELECT `Text` FROM `Control`";
3838     r = MsiDatabaseOpenView(hdb, query, &view);
3839     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3840     r = MsiViewExecute(view, 0);
3841     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3842
3843     r = MsiViewFetch(view, &rec);
3844     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3845
3846     size = MAX_PATH;
3847     r = MsiRecordGetString(rec, 1, result, &size);
3848     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3849     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3850
3851     MsiCloseHandle(rec);
3852
3853     r = MsiViewFetch(view, &rec);
3854     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3855
3856     size = MAX_PATH;
3857     r = MsiRecordGetString(rec, 1, result, &size);
3858     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3859     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3860
3861     MsiCloseHandle(rec);
3862
3863     r = MsiViewFetch(view, &rec);
3864     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3865
3866     size = MAX_PATH;
3867     r = MsiRecordGetString(rec, 1, result, &size);
3868     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3869     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3870
3871     MsiCloseHandle(rec);
3872
3873     r = MsiViewFetch(view, &rec);
3874     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3875
3876     r = MsiViewClose(view);
3877     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3878     r = MsiCloseHandle(view);
3879     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3880
3881     query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
3882         "`Orange` CHAR(72),  `Pear` INT PRIMARY KEY `Banana`)";
3883     r = run_query(hdb, 0, query);
3884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3885
3886     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3887         "VALUES('one', 'two', 3)";
3888     r = run_query(hdb, 0, query);
3889     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3890
3891     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3892         "VALUES('three', 'four', 5)";
3893     r = run_query(hdb, 0, query);
3894     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3895
3896     query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
3897         "VALUES('six', 'two', 7)";
3898     r = run_query(hdb, 0, query);
3899     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3900
3901     rec = MsiCreateRecord(2);
3902     MsiRecordSetInteger(rec, 1, 8);
3903     MsiRecordSetString(rec, 2, "two");
3904
3905     query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
3906     r = run_query(hdb, rec, query);
3907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3908
3909     MsiCloseHandle(rec);
3910
3911     query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
3912     r = MsiDatabaseOpenView(hdb, query, &view);
3913     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3914     r = MsiViewExecute(view, 0);
3915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3916
3917     r = MsiViewFetch(view, &rec);
3918     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3919
3920     r = MsiRecordGetInteger(rec, 1);
3921     ok(r == 8, "Expected 8, got %d\n", r);
3922
3923     MsiCloseHandle(rec);
3924
3925     r = MsiViewFetch(view, &rec);
3926     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3927
3928     r = MsiRecordGetInteger(rec, 1);
3929     ok(r == 8, "Expected 8, got %d\n", r);
3930
3931     MsiCloseHandle(rec);
3932
3933     r = MsiViewFetch(view, &rec);
3934     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3935
3936     r = MsiRecordGetInteger(rec, 1);
3937     ok(r == 5, "Expected 5, got %d\n", r);
3938
3939     MsiCloseHandle(rec);
3940
3941     r = MsiViewFetch(view, &rec);
3942     ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
3943
3944     MsiViewClose(view);
3945     MsiCloseHandle(view);
3946
3947     r = MsiDatabaseCommit(hdb);
3948     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
3949     r = MsiCloseHandle(hdb);
3950     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3951
3952     DeleteFile(msifile);
3953 }
3954
3955 static void test_special_tables(void)
3956 {
3957     const char *query;
3958     MSIHANDLE hdb = 0;
3959     UINT r;
3960
3961     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3962     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3963
3964     query = "CREATE TABLE `_Properties` ( "
3965         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3966     r = run_query(hdb, 0, query);
3967     ok(r == ERROR_SUCCESS, "failed to create table\n");
3968
3969     query = "CREATE TABLE `_Storages` ( "
3970         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3971     r = run_query(hdb, 0, query);
3972     todo_wine ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
3973
3974     query = "CREATE TABLE `_Streams` ( "
3975         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3976     r = run_query(hdb, 0, query);
3977     todo_wine ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
3978
3979     query = "CREATE TABLE `_Tables` ( "
3980         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3981     r = run_query(hdb, 0, query);
3982     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
3983
3984     query = "CREATE TABLE `_Columns` ( "
3985         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3986     r = run_query(hdb, 0, query);
3987     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
3988
3989     r = MsiCloseHandle(hdb);
3990     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3991 }
3992
3993 static void test_select_markers(void)
3994 {
3995     MSIHANDLE hdb = 0, rec, view, res;
3996     LPCSTR query;
3997     UINT r;
3998     DWORD size;
3999     CHAR buf[MAX_PATH];
4000
4001     hdb = create_db();
4002     ok( hdb, "failed to create db\n");
4003
4004     r = run_query(hdb, 0,
4005             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
4006     ok(r == S_OK, "cannot create table: %d\n", r);
4007
4008     r = run_query(hdb, 0, "INSERT INTO `Table` "
4009             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
4010     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4011
4012     r = run_query(hdb, 0, "INSERT INTO `Table` "
4013             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
4014     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4015
4016     r = run_query(hdb, 0, "INSERT INTO `Table` "
4017             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
4018     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4019
4020     r = run_query(hdb, 0, "INSERT INTO `Table` "
4021             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
4022     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
4023
4024     rec = MsiCreateRecord(2);
4025     MsiRecordSetString(rec, 1, "apple");
4026     MsiRecordSetString(rec, 2, "two");
4027
4028     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
4029     r = MsiDatabaseOpenView(hdb, query, &view);
4030     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4031
4032     r = MsiViewExecute(view, rec);
4033     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4034
4035     r = MsiViewFetch(view, &res);
4036     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4037
4038     size = MAX_PATH;
4039     r = MsiRecordGetString(res, 1, buf, &size);
4040     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4041     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
4042
4043     size = MAX_PATH;
4044     r = MsiRecordGetString(res, 2, buf, &size);
4045     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4046     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
4047
4048     r = MsiRecordGetInteger(res, 3);
4049     ok(r == 1, "Expected 1, got %d\n", r);
4050
4051     MsiCloseHandle(res);
4052
4053     r = MsiViewFetch(view, &res);
4054     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4055
4056     size = MAX_PATH;
4057     r = MsiRecordGetString(res, 1, buf, &size);
4058     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4059     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
4060
4061     size = MAX_PATH;
4062     r = MsiRecordGetString(res, 2, buf, &size);
4063     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4064     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
4065
4066     r = MsiRecordGetInteger(res, 3);
4067     ok(r == 2, "Expected 2, got %d\n", r);
4068
4069     MsiCloseHandle(res);
4070
4071     r = MsiViewFetch(view, &res);
4072     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4073
4074     MsiCloseHandle(rec);
4075     MsiViewClose(view);
4076     MsiCloseHandle(view);
4077
4078     rec = MsiCreateRecord(2);
4079     MsiRecordSetString(rec, 1, "one");
4080     MsiRecordSetInteger(rec, 2, 1);
4081
4082     query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
4083     r = MsiDatabaseOpenView(hdb, query, &view);
4084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4085     r = MsiViewExecute(view, rec);
4086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4087
4088     r = MsiViewFetch(view, &res);
4089     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4090
4091     size = MAX_PATH;
4092     r = MsiRecordGetString(res, 1, buf, &size);
4093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4094     ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
4095
4096     size = MAX_PATH;
4097     r = MsiRecordGetString(res, 2, buf, &size);
4098     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4099     ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
4100
4101     r = MsiRecordGetInteger(res, 3);
4102     ok(r == 2, "Expected 2, got %d\n", r);
4103
4104     MsiCloseHandle(res);
4105
4106     r = MsiViewFetch(view, &res);
4107     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4108
4109     size = MAX_PATH;
4110     r = MsiRecordGetString(res, 1, buf, &size);
4111     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4112     ok(!lstrcmp(buf, "banana"), "Expected banana, got %s\n", buf);
4113
4114     size = MAX_PATH;
4115     r = MsiRecordGetString(res, 2, buf, &size);
4116     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4117     ok(!lstrcmp(buf, "three"), "Expected three, got %s\n", buf);
4118
4119     r = MsiRecordGetInteger(res, 3);
4120     ok(r == 3, "Expected 3, got %d\n", r);
4121
4122     MsiCloseHandle(res);
4123
4124     r = MsiViewFetch(view, &res);
4125     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4126
4127     MsiCloseHandle(rec);
4128     MsiViewClose(view);
4129     MsiCloseHandle(view);
4130     MsiCloseHandle(hdb);
4131     DeleteFile(msifile);
4132 }
4133
4134 static void test_viewmodify_update(void)
4135 {
4136     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4137     const char *query;
4138     UINT r;
4139
4140     DeleteFile(msifile);
4141
4142     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4143     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
4144
4145     query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
4146     r = run_query( hdb, 0, query );
4147     ok(r == ERROR_SUCCESS, "query failed\n");
4148
4149     query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
4150     r = run_query( hdb, 0, query );
4151     ok(r == ERROR_SUCCESS, "query failed\n");
4152
4153     query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
4154     r = run_query( hdb, 0, query );
4155     ok(r == ERROR_SUCCESS, "query failed\n");
4156
4157     query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
4158     r = run_query( hdb, 0, query );
4159     ok(r == ERROR_SUCCESS, "query failed\n");
4160
4161     query = "SELECT `B` FROM `table`";
4162     r = MsiDatabaseOpenView(hdb, query, &hview);
4163     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4164     r = MsiViewExecute(hview, 0);
4165     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4166     r = MsiViewFetch(hview, &hrec);
4167     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4168
4169     r = MsiRecordSetInteger(hrec, 1, 0);
4170     ok(r == ERROR_SUCCESS, "failed to set integer\n");
4171
4172     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4173     ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
4174
4175     r = MsiCloseHandle(hrec);
4176     ok(r == ERROR_SUCCESS, "failed to close record\n");
4177
4178     r = MsiViewClose(hview);
4179     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4180     r = MsiCloseHandle(hview);
4181     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4182
4183     query = "SELECT * FROM `table`";
4184     r = MsiDatabaseOpenView(hdb, query, &hview);
4185     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4186     r = MsiViewExecute(hview, 0);
4187     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4188     r = MsiViewFetch(hview, &hrec);
4189     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4190
4191     r = MsiRecordGetInteger(hrec, 1);
4192     ok(r == 1, "Expected 1, got %d\n", r);
4193     r = MsiRecordGetInteger(hrec, 2);
4194     ok(r == 0, "Expected 0, got %d\n", r);
4195
4196     r = MsiCloseHandle(hrec);
4197     ok(r == ERROR_SUCCESS, "failed to close record\n");
4198
4199     r = MsiViewFetch(hview, &hrec);
4200     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4201
4202     r = MsiRecordGetInteger(hrec, 1);
4203     ok(r == 3, "Expected 3, got %d\n", r);
4204     r = MsiRecordGetInteger(hrec, 2);
4205     ok(r == 4, "Expected 4, got %d\n", r);
4206
4207     r = MsiCloseHandle(hrec);
4208     ok(r == ERROR_SUCCESS, "failed to close record\n");
4209
4210     r = MsiViewFetch(hview, &hrec);
4211     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4212
4213     r = MsiRecordGetInteger(hrec, 1);
4214     ok(r == 5, "Expected 5, got %d\n", r);
4215     r = MsiRecordGetInteger(hrec, 2);
4216     ok(r == 6, "Expected 6, got %d\n", r);
4217
4218     r = MsiCloseHandle(hrec);
4219     ok(r == ERROR_SUCCESS, "failed to close record\n");
4220
4221     r = MsiViewFetch(hview, &hrec);
4222     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4223
4224     r = MsiViewClose(hview);
4225     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4226     r = MsiCloseHandle(hview);
4227     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4228
4229     /* loop through all elements */
4230     query = "SELECT `B` FROM `table`";
4231     r = MsiDatabaseOpenView(hdb, query, &hview);
4232     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4233     r = MsiViewExecute(hview, 0);
4234     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4235
4236     while (TRUE)
4237     {
4238         r = MsiViewFetch(hview, &hrec);
4239         if (r != ERROR_SUCCESS)
4240             break;
4241
4242         r = MsiRecordSetInteger(hrec, 1, 0);
4243         ok(r == ERROR_SUCCESS, "failed to set integer\n");
4244
4245         r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
4246         ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
4247
4248         r = MsiCloseHandle(hrec);
4249         ok(r == ERROR_SUCCESS, "failed to close record\n");
4250     }
4251
4252     r = MsiViewClose(hview);
4253     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4254     r = MsiCloseHandle(hview);
4255     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4256
4257     query = "SELECT * FROM `table`";
4258     r = MsiDatabaseOpenView(hdb, query, &hview);
4259     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
4260     r = MsiViewExecute(hview, 0);
4261     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
4262     r = MsiViewFetch(hview, &hrec);
4263     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4264
4265     r = MsiRecordGetInteger(hrec, 1);
4266     ok(r == 1, "Expected 1, got %d\n", r);
4267     r = MsiRecordGetInteger(hrec, 2);
4268     ok(r == 0, "Expected 0, got %d\n", r);
4269
4270     r = MsiCloseHandle(hrec);
4271     ok(r == ERROR_SUCCESS, "failed to close record\n");
4272
4273     r = MsiViewFetch(hview, &hrec);
4274     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4275
4276     r = MsiRecordGetInteger(hrec, 1);
4277     ok(r == 3, "Expected 3, got %d\n", r);
4278     r = MsiRecordGetInteger(hrec, 2);
4279     ok(r == 0, "Expected 0, got %d\n", r);
4280
4281     r = MsiCloseHandle(hrec);
4282     ok(r == ERROR_SUCCESS, "failed to close record\n");
4283
4284     r = MsiViewFetch(hview, &hrec);
4285     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
4286
4287     r = MsiRecordGetInteger(hrec, 1);
4288     ok(r == 5, "Expected 5, got %d\n", r);
4289     r = MsiRecordGetInteger(hrec, 2);
4290     ok(r == 0, "Expected 0, got %d\n", r);
4291
4292     r = MsiCloseHandle(hrec);
4293     ok(r == ERROR_SUCCESS, "failed to close record\n");
4294
4295     r = MsiViewFetch(hview, &hrec);
4296     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4297
4298     r = MsiViewClose(hview);
4299     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
4300     r = MsiCloseHandle(hview);
4301     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
4302
4303     r = MsiCloseHandle( hdb );
4304     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
4305 }
4306
4307 static const WCHAR data10[] = { /* MOO */
4308     0x8001, 0x000b,
4309 };
4310 static const WCHAR data11[] = { /* AAR */
4311     0x8002, 0x8005,
4312     0x000c, 0x000f,
4313 };
4314 static const char data12[] = /* _StringData */
4315     "MOOABAARCDonetwofourfive";
4316 static const WCHAR data13[] = { /* _StringPool */
4317 /*  len, refs */
4318     0,   0,    /* string 0 ''     */
4319     0,   0,    /* string 1 ''     */
4320     0,   0,    /* string 2 ''     */
4321     0,   0,    /* string 3 ''     */
4322     0,   0,    /* string 4 ''     */
4323     3,   3,    /* string 5 'MOO'  */
4324     1,   1,    /* string 6 'A'    */
4325     1,   1,    /* string 7 'B'    */
4326     3,   3,    /* string 8 'AAR'  */
4327     1,   1,    /* string 9 'C'    */
4328     1,   1,    /* string a 'D'    */
4329     3,   1,    /* string b 'one'  */
4330     3,   1,    /* string c 'two'  */
4331     0,   0,    /* string d ''     */
4332     4,   1,    /* string e 'four' */
4333     4,   1,    /* string f 'five' */
4334 };
4335
4336 static void test_stringtable(void)
4337 {
4338     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4339     IStorage *stg = NULL;
4340     IStream *stm;
4341     WCHAR name[0x20];
4342     HRESULT hr;
4343     const char *query;
4344     char buffer[MAX_PATH];
4345     WCHAR data[MAX_PATH];
4346     DWORD sz, read;
4347     UINT r;
4348
4349     static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
4350     static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
4351     static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
4352     static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
4353     static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
4354
4355     DeleteFile(msifile);
4356
4357     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4358     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4359
4360     query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
4361     r = run_query(hdb, 0, query);
4362     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4363
4364     query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
4365     r = run_query(hdb, 0, query);
4366     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4367
4368     /* insert persistent row */
4369     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
4370     r = run_query(hdb, 0, query);
4371     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4372
4373     /* insert persistent row */
4374     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
4375     r = run_query(hdb, 0, query);
4376     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4377
4378     /* open a view */
4379     query = "SELECT * FROM `MOO`";
4380     r = MsiDatabaseOpenView(hdb, query, &hview);
4381     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4382     r = MsiViewExecute(hview, 0);
4383     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4384
4385     hrec = MsiCreateRecord(2);
4386
4387     r = MsiRecordSetInteger(hrec, 1, 3);
4388     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4389     r = MsiRecordSetString(hrec, 2, "three");
4390     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4391
4392     /* insert a nonpersistent row */
4393     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
4394     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4395
4396     r = MsiCloseHandle(hrec);
4397     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
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
4403     /* insert persistent row */
4404     query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
4405     r = run_query(hdb, 0, query);
4406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4407
4408     /* insert persistent row */
4409     query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
4410     r = run_query(hdb, 0, query);
4411     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4412
4413     r = MsiDatabaseCommit(hdb);
4414     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4415
4416     r = MsiCloseHandle(hdb);
4417     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4418
4419     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
4420     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4421
4422     query = "SELECT * FROM `MOO`";
4423     r = MsiDatabaseOpenView(hdb, query, &hview);
4424     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4425
4426     r = MsiViewExecute(hview, 0);
4427     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4428
4429     r = MsiViewFetch(hview, &hrec);
4430     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4431
4432     r = MsiRecordGetFieldCount(hrec);
4433     ok(r == 2, "Expected 2, got %d\n", r);
4434
4435     r = MsiRecordGetInteger(hrec, 1);
4436     ok(r == 1, "Expected 1, got %d\n", r);
4437
4438     sz = sizeof(buffer);
4439     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4441     ok(!lstrcmp(buffer, "one"), "Expected one, got %s\n", buffer);
4442
4443     r = MsiCloseHandle(hrec);
4444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4445
4446     r = MsiViewFetch(hview, &hrec);
4447     todo_wine
4448     {
4449         ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4450     }
4451
4452     r = MsiViewClose(hview);
4453     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4454     r = MsiCloseHandle(hview);
4455     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4456     r = MsiCloseHandle(hrec);
4457     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4458
4459     query = "SELECT * FROM `AAR`";
4460     r = MsiDatabaseOpenView(hdb, query, &hview);
4461     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4462
4463     r = MsiViewExecute(hview, 0);
4464     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4465
4466     r = MsiViewFetch(hview, &hrec);
4467     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4468
4469     r = MsiRecordGetFieldCount(hrec);
4470     ok(r == 2, "Expected 2, got %d\n", r);
4471
4472     r = MsiRecordGetInteger(hrec, 1);
4473     ok(r == 2, "Expected 2, got %d\n", r);
4474
4475     sz = sizeof(buffer);
4476     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4477     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4478     ok(!lstrcmp(buffer, "two"), "Expected two, got %s\n", buffer);
4479
4480     r = MsiCloseHandle(hrec);
4481     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4482
4483     r = MsiViewFetch(hview, &hrec);
4484     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4485
4486     r = MsiRecordGetFieldCount(hrec);
4487     ok(r == 2, "Expected 2, got %d\n", r);
4488
4489     r = MsiRecordGetInteger(hrec, 1);
4490     ok(r == 5, "Expected 5, got %d\n", r);
4491
4492     sz = sizeof(buffer);
4493     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4494     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4495     ok(!lstrcmp(buffer, "five"), "Expected five, got %s\n", buffer);
4496
4497     r = MsiCloseHandle(hrec);
4498     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4499
4500     r = MsiViewFetch(hview, &hrec);
4501     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4502
4503     r = MsiViewClose(hview);
4504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4505     r = MsiCloseHandle(hview);
4506     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4507     r = MsiCloseHandle(hrec);
4508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4509     r = MsiCloseHandle(hdb);
4510     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4511
4512     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
4513     hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
4514     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4515     ok(stg != NULL, "Expected non-NULL storage\n");
4516
4517     hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4518     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4519     ok(stm != NULL, "Expected non-NULL stream\n");
4520
4521     hr = IStream_Read(stm, data, MAX_PATH, &read);
4522     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4523     todo_wine
4524     {
4525         ok(read == 4, "Expected 4, got %d\n", read);
4526         ok(!memcmp(data, data10, read), "Unexpected data\n");
4527     }
4528
4529     hr = IStream_Release(stm);
4530     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4531
4532     hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4533     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4534     ok(stm != NULL, "Expected non-NULL stream\n");
4535
4536     hr = IStream_Read(stm, data, MAX_PATH, &read);
4537     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4538     ok(read == 8, "Expected 8, got %d\n", read);
4539     todo_wine
4540     {
4541         ok(!memcmp(data, data11, read), "Unexpected data\n");
4542     }
4543
4544     hr = IStream_Release(stm);
4545     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4546
4547     hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4548     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4549     ok(stm != NULL, "Expected non-NULL stream\n");
4550
4551     hr = IStream_Read(stm, buffer, MAX_PATH, &read);
4552     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4553     ok(read == 24, "Expected 24, got %d\n", read);
4554     ok(!memcmp(buffer, data12, read), "Unexpected data\n");
4555
4556     hr = IStream_Release(stm);
4557     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4558
4559     hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4560     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4561     ok(stm != NULL, "Expected non-NULL stream\n");
4562
4563     hr = IStream_Read(stm, data, MAX_PATH, &read);
4564     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4565     todo_wine
4566     {
4567         ok(read == 64, "Expected 64, got %d\n", read);
4568         ok(!memcmp(data, data13, read), "Unexpected data\n");
4569     }
4570
4571     hr = IStream_Release(stm);
4572     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4573
4574     hr = IStorage_Release(stg);
4575     ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
4576
4577     DeleteFileA(msifile);
4578 }
4579
4580 static void test_viewmodify_delete(void)
4581 {
4582     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
4583     UINT r;
4584     const char *query;
4585     char buffer[0x100];
4586     DWORD sz;
4587
4588     DeleteFile(msifile);
4589
4590     /* just MsiOpenDatabase should not create a file */
4591     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4592     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4593
4594     query = "CREATE TABLE `phone` ( "
4595             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
4596             "PRIMARY KEY `id`)";
4597     r = run_query(hdb, 0, query);
4598     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4599
4600     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4601         "VALUES('1', 'Alan', '5030581')";
4602     r = run_query(hdb, 0, query);
4603     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4604
4605     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4606         "VALUES('2', 'Barry', '928440')";
4607     r = run_query(hdb, 0, query);
4608     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4609
4610     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
4611         "VALUES('3', 'Cindy', '2937550')";
4612     r = run_query(hdb, 0, query);
4613     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4614
4615     query = "SELECT * FROM `phone` WHERE `id` <= 2";
4616     r = MsiDatabaseOpenView(hdb, query, &hview);
4617     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4618     r = MsiViewExecute(hview, 0);
4619     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4620     r = MsiViewFetch(hview, &hrec);
4621     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4622
4623     /* delete 1 */
4624     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4625     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4626
4627     r = MsiCloseHandle(hrec);
4628     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4629     r = MsiViewFetch(hview, &hrec);
4630     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4631
4632     /* delete 2 */
4633     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
4634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4635
4636     r = MsiCloseHandle(hrec);
4637     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4638     r = MsiViewClose(hview);
4639     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4640     r = MsiCloseHandle(hview);
4641     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4642
4643     query = "SELECT * FROM `phone`";
4644     r = MsiDatabaseOpenView(hdb, query, &hview);
4645     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4646     r = MsiViewExecute(hview, 0);
4647     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4648     r = MsiViewFetch(hview, &hrec);
4649     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4650
4651     r = MsiRecordGetInteger(hrec, 1);
4652     ok(r == 3, "Expected 3, got %d\n", r);
4653
4654     sz = sizeof(buffer);
4655     r = MsiRecordGetString(hrec, 2, buffer, &sz);
4656     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4657     ok(!lstrcmp(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
4658
4659     sz = sizeof(buffer);
4660     r = MsiRecordGetString(hrec, 3, buffer, &sz);
4661     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4662     ok(!lstrcmp(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
4663
4664     r = MsiCloseHandle(hrec);
4665     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4666
4667     r = MsiViewFetch(hview, &hrec);
4668     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4669
4670     r = MsiViewClose(hview);
4671     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4672     r = MsiCloseHandle(hview);
4673     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4674     r = MsiCloseHandle(hdb);
4675     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4676 }
4677
4678 static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
4679 static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
4680 static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
4681
4682 static const WCHAR data14[] = { /* _StringPool */
4683 /*  len, refs */
4684     0,   0,    /* string 0 ''    */
4685 };
4686
4687 static const struct {
4688     LPCWSTR name;
4689     const void *data;
4690     DWORD size;
4691 } database_table_data[] =
4692 {
4693     {_Tables, NULL, 0},
4694     {_StringData, NULL, 0},
4695     {_StringPool, data14, sizeof data14},
4696 };
4697
4698 void enum_stream_names(IStorage *stg)
4699 {
4700     IEnumSTATSTG *stgenum = NULL;
4701     IStream *stm;
4702     HRESULT hr;
4703     STATSTG stat;
4704     ULONG n, count;
4705     BYTE data[MAX_PATH];
4706     BYTE check[MAX_PATH];
4707     DWORD sz;
4708
4709     memset(check, 'a', MAX_PATH);
4710
4711     hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
4712     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4713
4714     n = 0;
4715     while(TRUE)
4716     {
4717         count = 0;
4718         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
4719         if(FAILED(hr) || !count)
4720             break;
4721
4722         ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
4723            "Expected table %d name to match\n", n);
4724
4725         stm = NULL;
4726         hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
4727                                  STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
4728         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4729         ok(stm != NULL, "Expected non-NULL stream\n");
4730
4731         sz = MAX_PATH;
4732         memset(data, 'a', MAX_PATH);
4733         hr = IStream_Read(stm, data, sz, &count);
4734         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4735
4736         ok(count == database_table_data[n].size,
4737            "Expected %d, got %d\n", database_table_data[n].size, count);
4738
4739         if (!database_table_data[n].size)
4740             ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
4741         else
4742             ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
4743                "Expected table %d data to match\n", n);
4744
4745         IStream_Release(stm);
4746         n++;
4747     }
4748
4749     ok(n == 3, "Expected 3, got %d\n", n);
4750
4751     IEnumSTATSTG_Release(stgenum);
4752 }
4753
4754 static void test_defaultdatabase(void)
4755 {
4756     UINT r;
4757     HRESULT hr;
4758     MSIHANDLE hdb;
4759     IStorage *stg = NULL;
4760
4761     static const WCHAR msifileW[] = {'w','i','n','e','t','e','s','t','.','m','s','i',0};
4762
4763     DeleteFile(msifile);
4764
4765     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
4766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4767
4768     r = MsiDatabaseCommit(hdb);
4769     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4770
4771     MsiCloseHandle(hdb);
4772
4773     hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
4774     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
4775     ok(stg != NULL, "Expected non-NULL stg\n");
4776
4777     enum_stream_names(stg);
4778
4779     IStorage_Release(stg);
4780     DeleteFileA(msifile);
4781 }
4782
4783 static void test_order(void)
4784 {
4785     MSIHANDLE hdb, hview, hrec;
4786     CHAR buffer[MAX_PATH];
4787     LPCSTR query;
4788     UINT r, sz;
4789     int val;
4790
4791     hdb = create_db();
4792     ok(hdb, "failed to create db\n");
4793
4794     query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
4795     r = run_query(hdb, 0, query);
4796     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4797
4798     query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
4799     r = run_query(hdb, 0, query);
4800     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4801
4802     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
4803     r = run_query(hdb, 0, query);
4804     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4805
4806     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
4807     r = run_query(hdb, 0, query);
4808     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4809
4810     query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
4811     r = run_query(hdb, 0, query);
4812     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4813
4814     query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
4815     r = run_query(hdb, 0, query);
4816     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4817
4818     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
4819     r = run_query(hdb, 0, query);
4820     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4821
4822     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
4823     r = run_query(hdb, 0, query);
4824     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4825
4826     query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
4827     r = run_query(hdb, 0, query);
4828     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4829
4830     query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
4831     r = MsiDatabaseOpenView(hdb, query, &hview);
4832     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4833     r = MsiViewExecute(hview, 0);
4834     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4835
4836     r = MsiViewFetch(hview, &hrec);
4837     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4838
4839     val = MsiRecordGetInteger(hrec, 1);
4840     ok(val == 3, "Expected 3, got %d\n", val);
4841
4842     val = MsiRecordGetInteger(hrec, 2);
4843     ok(val == 4, "Expected 3, got %d\n", val);
4844
4845     MsiCloseHandle(hrec);
4846
4847     r = MsiViewFetch(hview, &hrec);
4848     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4849
4850     val = MsiRecordGetInteger(hrec, 1);
4851     ok(val == 5, "Expected 5, got %d\n", val);
4852
4853     val = MsiRecordGetInteger(hrec, 2);
4854     ok(val == 6, "Expected 6, got %d\n", val);
4855
4856     MsiCloseHandle(hrec);
4857
4858     r = MsiViewFetch(hview, &hrec);
4859     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4860
4861     val = MsiRecordGetInteger(hrec, 1);
4862     ok(val == 1, "Expected 1, got %d\n", val);
4863
4864     val = MsiRecordGetInteger(hrec, 2);
4865     ok(val == 2, "Expected 2, got %d\n", val);
4866
4867     MsiCloseHandle(hrec);
4868
4869     r = MsiViewFetch(hview, &hrec);
4870     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4871
4872     MsiViewClose(hview);
4873     MsiCloseHandle(hview);
4874
4875     query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
4876     r = MsiDatabaseOpenView(hdb, query, &hview);
4877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4878     r = MsiViewExecute(hview, 0);
4879     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4880
4881     r = MsiViewFetch(hview, &hrec);
4882     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4883
4884     val = MsiRecordGetInteger(hrec, 1);
4885     ok(val == 1, "Expected 1, got %d\n", val);
4886
4887     val = MsiRecordGetInteger(hrec, 2);
4888     ok(val == 12, "Expected 12, got %d\n", val);
4889
4890     MsiCloseHandle(hrec);
4891
4892     r = MsiViewFetch(hview, &hrec);
4893     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4894
4895     val = MsiRecordGetInteger(hrec, 1);
4896     ok(val == 3, "Expected 3, got %d\n", val);
4897
4898     val = MsiRecordGetInteger(hrec, 2);
4899     ok(val == 12, "Expected 12, got %d\n", val);
4900
4901     MsiCloseHandle(hrec);
4902
4903     r = MsiViewFetch(hview, &hrec);
4904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4905
4906     val = MsiRecordGetInteger(hrec, 1);
4907     ok(val == 5, "Expected 5, got %d\n", val);
4908
4909     val = MsiRecordGetInteger(hrec, 2);
4910     ok(val == 12, "Expected 12, got %d\n", val);
4911
4912     MsiCloseHandle(hrec);
4913
4914     r = MsiViewFetch(hview, &hrec);
4915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4916
4917     val = MsiRecordGetInteger(hrec, 1);
4918     ok(val == 1, "Expected 1, got %d\n", val);
4919
4920     val = MsiRecordGetInteger(hrec, 2);
4921     ok(val == 14, "Expected 14, got %d\n", val);
4922
4923     MsiCloseHandle(hrec);
4924
4925     r = MsiViewFetch(hview, &hrec);
4926     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4927
4928     val = MsiRecordGetInteger(hrec, 1);
4929     ok(val == 3, "Expected 3, got %d\n", val);
4930
4931     val = MsiRecordGetInteger(hrec, 2);
4932     ok(val == 14, "Expected 14, got %d\n", val);
4933
4934     MsiCloseHandle(hrec);
4935
4936     r = MsiViewFetch(hview, &hrec);
4937     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4938
4939     val = MsiRecordGetInteger(hrec, 1);
4940     ok(val == 5, "Expected 5, got %d\n", val);
4941
4942     val = MsiRecordGetInteger(hrec, 2);
4943     ok(val == 14, "Expected 14, got %d\n", val);
4944
4945     MsiCloseHandle(hrec);
4946
4947     r = MsiViewFetch(hview, &hrec);
4948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4949
4950     val = MsiRecordGetInteger(hrec, 1);
4951     ok(val == 1, "Expected 1, got %d\n", val);
4952
4953     val = MsiRecordGetInteger(hrec, 2);
4954     ok(val == 10, "Expected 10, got %d\n", val);
4955
4956     MsiCloseHandle(hrec);
4957
4958     r = MsiViewFetch(hview, &hrec);
4959     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4960
4961     val = MsiRecordGetInteger(hrec, 1);
4962     ok(val == 3, "Expected 3, got %d\n", val);
4963
4964     val = MsiRecordGetInteger(hrec, 2);
4965     ok(val == 10, "Expected 10, got %d\n", val);
4966
4967     MsiCloseHandle(hrec);
4968
4969     r = MsiViewFetch(hview, &hrec);
4970     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4971
4972     val = MsiRecordGetInteger(hrec, 1);
4973     ok(val == 5, "Expected 5, got %d\n", val);
4974
4975     val = MsiRecordGetInteger(hrec, 2);
4976     ok(val == 10, "Expected 10, got %d\n", val);
4977
4978     MsiCloseHandle(hrec);
4979
4980     r = MsiViewFetch(hview, &hrec);
4981     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4982
4983     MsiViewClose(hview);
4984     MsiCloseHandle(hview);
4985
4986     query = "SELECT * FROM `Empty` ORDER BY `A`";
4987     r = MsiDatabaseOpenView(hdb, query, &hview);
4988     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4989     r = MsiViewExecute(hview, 0);
4990     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
4991
4992     r = MsiViewFetch(hview, &hrec);
4993     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
4994
4995     MsiViewClose(hview);
4996     MsiCloseHandle(hview);
4997
4998     query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
4999     r = run_query(hdb, 0, query);
5000     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5001
5002     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno',  2)";
5003     r = run_query(hdb, 0, query);
5004     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5005
5006     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos',  3)";
5007     r = run_query(hdb, 0, query);
5008     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5009
5010     query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres',  1)";
5011     r = run_query(hdb, 0, query);
5012     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5013
5014     query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
5015     r = MsiDatabaseOpenView(hdb, query, &hview);
5016     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5017     r = MsiViewExecute(hview, 0);
5018     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5019
5020     r = MsiViewFetch(hview, &hrec);
5021     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5022
5023     sz = sizeof(buffer);
5024     r = MsiRecordGetString(hrec, 1, buffer, &sz);
5025     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5026     ok(!lstrcmp(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
5027
5028     r = MsiRecordGetInteger(hrec, 2);
5029     ok(r == 3, "Expected 3, got %d\n", r);
5030
5031     MsiCloseHandle(hrec);
5032
5033     r = MsiViewFetch(hview, &hrec);
5034     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5035
5036     MsiViewClose(hview);
5037     MsiCloseHandle(hview);
5038     MsiCloseHandle(hdb);
5039 }
5040
5041 static void test_viewmodify_delete_temporary(void)
5042 {
5043     MSIHANDLE hdb, hview, hrec;
5044     const char *query;
5045     UINT r;
5046
5047     DeleteFile(msifile);
5048
5049     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5050     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5051
5052     query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
5053     r = run_query(hdb, 0, query);
5054     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5055
5056     query = "SELECT * FROM `Table`";
5057     r = MsiDatabaseOpenView(hdb, query, &hview);
5058     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5059     r = MsiViewExecute(hview, 0);
5060     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5061
5062     hrec = MsiCreateRecord(1);
5063     MsiRecordSetInteger(hrec, 1, 1);
5064
5065     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
5066     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5067
5068     MsiCloseHandle(hrec);
5069
5070     hrec = MsiCreateRecord(1);
5071     MsiRecordSetInteger(hrec, 1, 2);
5072
5073     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5074     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5075
5076     MsiCloseHandle(hrec);
5077
5078     hrec = MsiCreateRecord(1);
5079     MsiRecordSetInteger(hrec, 1, 3);
5080
5081     r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
5082     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5083
5084     MsiCloseHandle(hrec);
5085
5086     hrec = MsiCreateRecord(1);
5087     MsiRecordSetInteger(hrec, 1, 4);
5088
5089     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5090     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5091
5092     MsiCloseHandle(hrec);
5093     MsiViewClose(hview);
5094     MsiCloseHandle(hview);
5095
5096     query = "SELECT * FROM `Table` WHERE  `A` = 2";
5097     r = MsiDatabaseOpenView(hdb, query, &hview);
5098     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5099     r = MsiViewExecute(hview, 0);
5100     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5101     r = MsiViewFetch(hview, &hrec);
5102     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5103
5104     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
5105     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5106
5107     MsiCloseHandle(hrec);
5108     MsiViewClose(hview);
5109     MsiCloseHandle(hview);
5110
5111     query = "SELECT * FROM `Table` WHERE  `A` = 3";
5112     r = MsiDatabaseOpenView(hdb, query, &hview);
5113     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5114     r = MsiViewExecute(hview, 0);
5115     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5116     r = MsiViewFetch(hview, &hrec);
5117     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5118
5119     r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
5120     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5121
5122     MsiCloseHandle(hrec);
5123     MsiViewClose(hview);
5124     MsiCloseHandle(hview);
5125
5126     query = "SELECT * FROM `Table` ORDER BY `A`";
5127     r = MsiDatabaseOpenView(hdb, query, &hview);
5128     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5129     r = MsiViewExecute(hview, 0);
5130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5131
5132     r = MsiViewFetch(hview, &hrec);
5133     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5134
5135     r = MsiRecordGetInteger(hrec, 1);
5136     ok(r == 1, "Expected 1, got %d\n", r);
5137
5138     MsiCloseHandle(hrec);
5139
5140     r = MsiViewFetch(hview, &hrec);
5141     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5142
5143     r = MsiRecordGetInteger(hrec, 1);
5144     ok(r == 4, "Expected 4, got %d\n", r);
5145
5146     MsiCloseHandle(hrec);
5147
5148     r = MsiViewFetch(hview, &hrec);
5149     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5150
5151     MsiViewClose(hview);
5152     MsiCloseHandle(hview);
5153     MsiCloseHandle(hdb);
5154     DeleteFileA(msifile);
5155 }
5156
5157 static void test_deleterow()
5158 {
5159     MSIHANDLE hdb, hview, hrec;
5160     const char *query;
5161     char buf[MAX_PATH];
5162     UINT r;
5163     DWORD size;
5164
5165     DeleteFile(msifile);
5166
5167     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5168     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5169
5170     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5171     r = run_query(hdb, 0, query);
5172     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5173
5174     query = "INSERT INTO `Table` (`A`) VALUES ('one')";
5175     r = run_query(hdb, 0, query);
5176     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5177
5178     query = "INSERT INTO `Table` (`A`) VALUES ('two')";
5179     r = run_query(hdb, 0, query);
5180     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5181
5182     query = "DELETE FROM `Table` WHERE `A` = 'one'";
5183     r = run_query(hdb, 0, query);
5184     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5185
5186     r = MsiDatabaseCommit(hdb);
5187     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5188
5189     MsiCloseHandle(hdb);
5190
5191     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
5192     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5193
5194     query = "SELECT * FROM `Table`";
5195     r = MsiDatabaseOpenView(hdb, query, &hview);
5196     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5197     r = MsiViewExecute(hview, 0);
5198     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5199
5200     r = MsiViewFetch(hview, &hrec);
5201     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5202
5203     size = MAX_PATH;
5204     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5205     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5206     ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
5207
5208     MsiCloseHandle(hrec);
5209
5210     r = MsiViewFetch(hview, &hrec);
5211     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5212
5213     MsiViewClose(hview);
5214     MsiCloseHandle(hview);
5215     MsiCloseHandle(hdb);
5216     DeleteFileA(msifile);
5217 }
5218
5219 static const CHAR import_dat[] = "A\n"
5220                                  "s72\n"
5221                                  "Table\tA\n"
5222                                  "This is a new 'string' ok\n";
5223
5224 static void test_quotes(void)
5225 {
5226     MSIHANDLE hdb, hview, hrec;
5227     const char *query;
5228     char buf[MAX_PATH];
5229     UINT r;
5230     DWORD size;
5231
5232     DeleteFile(msifile);
5233
5234     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5235     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5236
5237     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5238     r = run_query(hdb, 0, query);
5239     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5240
5241     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
5242     r = run_query(hdb, 0, query);
5243     ok(r == ERROR_BAD_QUERY_SYNTAX,
5244        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5245
5246     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
5247     r = run_query(hdb, 0, query);
5248     ok(r == ERROR_BAD_QUERY_SYNTAX,
5249        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5250
5251     query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
5252     r = run_query(hdb, 0, query);
5253     ok(r == ERROR_BAD_QUERY_SYNTAX,
5254        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5255
5256     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
5257     r = run_query(hdb, 0, query);
5258     todo_wine
5259     {
5260         ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5261     }
5262
5263     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
5264     r = run_query(hdb, 0, query);
5265     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5266
5267     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
5268     r = run_query(hdb, 0, query);
5269     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5270
5271     query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
5272     r = run_query(hdb, 0, query);
5273     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5274
5275     query = "SELECT * FROM `Table`";
5276     r = MsiDatabaseOpenView(hdb, query, &hview);
5277     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5278
5279     r = MsiViewExecute(hview, 0);
5280     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5281
5282     r = MsiViewFetch(hview, &hrec);
5283     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5284
5285     size = MAX_PATH;
5286     r = MsiRecordGetString(hrec, 1, buf, &size);
5287     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5288     todo_wine
5289     {
5290         ok(!lstrcmp(buf, "This is a \"string\" ok"),
5291            "Expected \"This is a \"string\" ok\", got %s\n", buf);
5292     }
5293
5294     MsiCloseHandle(hrec);
5295
5296     r = MsiViewFetch(hview, &hrec);
5297     todo_wine
5298     {
5299         ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5300     }
5301
5302     MsiCloseHandle(hview);
5303
5304     write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
5305
5306     r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
5307     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5308
5309     DeleteFileA("import.idt");
5310
5311     query = "SELECT * FROM `Table`";
5312     r = MsiDatabaseOpenView(hdb, query, &hview);
5313     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5314
5315     r = MsiViewExecute(hview, 0);
5316     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5317
5318     r = MsiViewFetch(hview, &hrec);
5319     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5320
5321     size = MAX_PATH;
5322     r = MsiRecordGetString(hrec, 1, buf, &size);
5323     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5324     ok(!lstrcmp(buf, "This is a new 'string' ok"),
5325        "Expected \"This is a new 'string' ok\", got %s\n", buf);
5326
5327     MsiCloseHandle(hrec);
5328
5329     r = MsiViewFetch(hview, &hrec);
5330     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5331
5332     MsiCloseHandle(hview);
5333
5334     MsiCloseHandle(hdb);
5335     DeleteFileA(msifile);
5336 }
5337
5338 static void test_carriagereturn(void)
5339 {
5340     MSIHANDLE hdb, hview, hrec;
5341     const char *query;
5342     char buf[MAX_PATH];
5343     UINT r;
5344     DWORD size;
5345
5346     DeleteFile(msifile);
5347
5348     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5349     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5350
5351     query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5352     r = run_query(hdb, 0, query);
5353     todo_wine
5354     {
5355         ok(r == ERROR_BAD_QUERY_SYNTAX,
5356            "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5357     }
5358
5359     query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5360     r = run_query(hdb, 0, query);
5361     ok(r == ERROR_BAD_QUERY_SYNTAX,
5362        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5363
5364     query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5365     r = run_query(hdb, 0, query);
5366     ok(r == ERROR_BAD_QUERY_SYNTAX,
5367        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5368
5369     query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5370     r = run_query(hdb, 0, query);
5371     ok(r == ERROR_BAD_QUERY_SYNTAX,
5372        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5373
5374     query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5375     r = run_query(hdb, 0, query);
5376     ok(r == ERROR_BAD_QUERY_SYNTAX,
5377        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5378
5379     query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
5380     r = run_query(hdb, 0, query);
5381     ok(r == ERROR_BAD_QUERY_SYNTAX,
5382        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5383
5384     query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
5385     r = run_query(hdb, 0, query);
5386     ok(r == ERROR_BAD_QUERY_SYNTAX,
5387        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5388
5389     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
5390     r = run_query(hdb, 0, query);
5391     ok(r == ERROR_BAD_QUERY_SYNTAX,
5392        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5393
5394     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
5395     r = run_query(hdb, 0, query);
5396     ok(r == ERROR_BAD_QUERY_SYNTAX,
5397        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5398
5399     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
5400     r = run_query(hdb, 0, query);
5401     ok(r == ERROR_BAD_QUERY_SYNTAX,
5402        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5403
5404     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
5405     r = run_query(hdb, 0, query);
5406     ok(r == ERROR_BAD_QUERY_SYNTAX,
5407        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5408
5409     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
5410     r = run_query(hdb, 0, query);
5411     ok(r == ERROR_BAD_QUERY_SYNTAX,
5412        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5413
5414     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
5415     r = run_query(hdb, 0, query);
5416     ok(r == ERROR_BAD_QUERY_SYNTAX,
5417        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5418
5419     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
5420     r = run_query(hdb, 0, query);
5421     ok(r == ERROR_BAD_QUERY_SYNTAX,
5422        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5423
5424     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
5425     r = run_query(hdb, 0, query);
5426     ok(r == ERROR_BAD_QUERY_SYNTAX,
5427        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5428
5429     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
5430     r = run_query(hdb, 0, query);
5431     ok(r == ERROR_BAD_QUERY_SYNTAX,
5432        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5433
5434     query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5435     r = run_query(hdb, 0, query);
5436     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5437
5438     query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5439     r = run_query(hdb, 0, query);
5440     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5441
5442     query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5443     r = run_query(hdb, 0, query);
5444     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5445
5446     query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5447     r = run_query(hdb, 0, query);
5448     ok(r == ERROR_BAD_QUERY_SYNTAX,
5449        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5450
5451     query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5452     r = run_query(hdb, 0, query);
5453     ok(r == ERROR_BAD_QUERY_SYNTAX,
5454        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5455
5456     query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
5457     r = run_query(hdb, 0, query);
5458     todo_wine
5459     {
5460         ok(r == ERROR_BAD_QUERY_SYNTAX,
5461            "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5462     }
5463
5464     query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
5465     r = run_query(hdb, 0, query);
5466     ok(r == ERROR_BAD_QUERY_SYNTAX,
5467        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5468
5469     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
5470     r = run_query(hdb, 0, query);
5471     ok(r == ERROR_BAD_QUERY_SYNTAX,
5472        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5473
5474     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
5475     r = run_query(hdb, 0, query);
5476     ok(r == ERROR_BAD_QUERY_SYNTAX,
5477        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5478
5479     query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
5480     r = run_query(hdb, 0, query);
5481     ok(r == ERROR_BAD_QUERY_SYNTAX,
5482        "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5483
5484     query = "SELECT * FROM `_Tables`";
5485     r = MsiDatabaseOpenView(hdb, query, &hview);
5486     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5487     r = MsiViewExecute(hview, 0);
5488     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5489
5490     r = MsiViewFetch(hview, &hrec);
5491     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5492
5493     size = MAX_PATH;
5494     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5495     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5496     todo_wine
5497     {
5498         ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
5499     }
5500
5501     MsiCloseHandle(hrec);
5502
5503     r = MsiViewFetch(hview, &hrec);
5504     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5505
5506     size = MAX_PATH;
5507     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5508     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5509     todo_wine
5510     {
5511         ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
5512     }
5513
5514     MsiCloseHandle(hrec);
5515
5516     r = MsiViewFetch(hview, &hrec);
5517     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5518
5519     size = MAX_PATH;
5520     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5521     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5522     todo_wine
5523     {
5524         ok(!lstrcmpA(buf, "Three\r"),
5525            "Expected \"Three\r\", got \"%s\"\n", buf);
5526     }
5527
5528     MsiCloseHandle(hrec);
5529
5530     r = MsiViewFetch(hview, &hrec);
5531     todo_wine
5532     {
5533         ok(r == ERROR_NO_MORE_ITEMS,
5534            "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5535     }
5536
5537     MsiViewClose(hview);
5538     MsiCloseHandle(hview);
5539
5540     MsiCloseHandle(hdb);
5541     DeleteFileA(msifile);
5542 }
5543
5544 static void test_noquotes(void)
5545 {
5546     MSIHANDLE hdb, hview, hrec;
5547     const char *query;
5548     char buf[MAX_PATH];
5549     UINT r;
5550     DWORD size;
5551
5552     DeleteFile(msifile);
5553
5554     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5555     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5556
5557     query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5558     r = run_query(hdb, 0, query);
5559     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5560
5561     query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
5562     r = run_query(hdb, 0, query);
5563     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5564
5565     query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
5566     r = run_query(hdb, 0, query);
5567     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5568
5569     query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
5570     r = run_query(hdb, 0, query);
5571     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5572
5573     query = "SELECT * FROM `_Tables`";
5574     r = MsiDatabaseOpenView(hdb, query, &hview);
5575     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5576     r = MsiViewExecute(hview, 0);
5577     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5578
5579     r = MsiViewFetch(hview, &hrec);
5580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5581
5582     size = MAX_PATH;
5583     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5584     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5585     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
5586
5587     MsiCloseHandle(hrec);
5588
5589     r = MsiViewFetch(hview, &hrec);
5590     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5591
5592     size = MAX_PATH;
5593     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5594     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5595     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
5596
5597     MsiCloseHandle(hrec);
5598
5599     r = MsiViewFetch(hview, &hrec);
5600     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5601
5602     size = MAX_PATH;
5603     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5604     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5605     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
5606
5607     MsiCloseHandle(hrec);
5608
5609     r = MsiViewFetch(hview, &hrec);
5610     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5611
5612     MsiViewClose(hview);
5613     MsiCloseHandle(hview);
5614
5615     query = "SELECT * FROM `_Columns`";
5616     r = MsiDatabaseOpenView(hdb, query, &hview);
5617     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5618     r = MsiViewExecute(hview, 0);
5619     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5620
5621     r = MsiViewFetch(hview, &hrec);
5622     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5623
5624     size = MAX_PATH;
5625     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5626     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5627     ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
5628
5629     r = MsiRecordGetInteger(hrec, 2);
5630     ok(r == 1, "Expected 1, got %d\n", r);
5631
5632     size = MAX_PATH;
5633     r = MsiRecordGetStringA(hrec, 3, buf, &size);
5634     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5635     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
5636
5637     MsiCloseHandle(hrec);
5638
5639     r = MsiViewFetch(hview, &hrec);
5640     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5641
5642     size = MAX_PATH;
5643     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5644     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5645     ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
5646
5647     r = MsiRecordGetInteger(hrec, 2);
5648     ok(r == 1, "Expected 1, got %d\n", r);
5649
5650     size = MAX_PATH;
5651     r = MsiRecordGetStringA(hrec, 3, buf, &size);
5652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5653     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
5654
5655     MsiCloseHandle(hrec);
5656
5657     r = MsiViewFetch(hview, &hrec);
5658     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5659
5660     size = MAX_PATH;
5661     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5662     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5663     ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
5664
5665     r = MsiRecordGetInteger(hrec, 2);
5666     ok(r == 1, "Expected 1, got %d\n", r);
5667
5668     size = MAX_PATH;
5669     r = MsiRecordGetStringA(hrec, 3, buf, &size);
5670     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5671     ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
5672
5673     MsiCloseHandle(hrec);
5674
5675     r = MsiViewFetch(hview, &hrec);
5676     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5677
5678     MsiViewClose(hview);
5679     MsiCloseHandle(hview);
5680
5681     query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
5682     r = run_query(hdb, 0, query);
5683     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5684
5685     query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
5686     r = run_query(hdb, 0, query);
5687     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5688
5689     query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
5690     r = run_query(hdb, 0, query);
5691     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5692
5693     query = "SELECT * FROM Table WHERE `A` = 'hi'";
5694     r = run_query(hdb, 0, query);
5695     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5696
5697     query = "SELECT * FROM `Table` WHERE `A` = hi";
5698     r = run_query(hdb, 0, query);
5699     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5700
5701     query = "SELECT * FROM Table";
5702     r = run_query(hdb, 0, query);
5703     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5704
5705     query = "SELECT * FROM Table2";
5706     r = MsiDatabaseOpenView(hdb, query, &hview);
5707     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5708     r = MsiViewExecute(hview, 0);
5709     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5710
5711     r = MsiViewFetch(hview, &hrec);
5712     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5713
5714     MsiViewClose(hview);
5715     MsiCloseHandle(hview);
5716
5717     query = "SELECT * FROM `Table` WHERE A = 'hi'";
5718     r = MsiDatabaseOpenView(hdb, query, &hview);
5719     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5720     r = MsiViewExecute(hview, 0);
5721     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5722
5723     r = MsiViewFetch(hview, &hrec);
5724     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5725
5726     size = MAX_PATH;
5727     r = MsiRecordGetStringA(hrec, 1, buf, &size);
5728     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5729     ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
5730
5731     MsiCloseHandle(hrec);
5732
5733     r = MsiViewFetch(hview, &hrec);
5734     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
5735
5736     MsiViewClose(hview);
5737     MsiCloseHandle(hview);
5738
5739
5740     MsiCloseHandle(hdb);
5741     DeleteFileA(msifile);
5742 }
5743
5744 static void read_file_data(LPCSTR filename, LPSTR buffer)
5745 {
5746     OFSTRUCT ofs;
5747     HFILE file;
5748     DWORD read;
5749
5750     file = OpenFile(filename, &ofs, OF_READ);
5751     ZeroMemory(buffer, MAX_PATH);
5752     ReadFile((HANDLE)file, buffer, MAX_PATH, &read, NULL);
5753     CloseHandle((HANDLE)file);
5754 }
5755
5756 static void test_forcecodepage(void)
5757 {
5758     MSIHANDLE hdb;
5759     const char *query;
5760     char buffer[MAX_PATH];
5761     UINT r;
5762
5763     DeleteFile(msifile);
5764
5765     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5766     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5767
5768     query = "SELECT * FROM `_ForceCodepage`";
5769     r = run_query(hdb, 0, query);
5770     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5771
5772     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
5773     r = run_query(hdb, 0, query);
5774     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5775
5776     query = "SELECT * FROM `_ForceCodepage`";
5777     r = run_query(hdb, 0, query);
5778     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5779
5780     r = MsiDatabaseCommit(hdb);
5781     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5782
5783     query = "SELECT * FROM `_ForceCodepage`";
5784     r = run_query(hdb, 0, query);
5785     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5786
5787     MsiCloseHandle(hdb);
5788
5789     r = MsiOpenDatabase(msifile, MSIDBOPEN_DIRECT, &hdb);
5790     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5791
5792     query = "SELECT * FROM `_ForceCodepage`";
5793     r = run_query(hdb, 0, query);
5794     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
5795
5796     r = MsiDatabaseExport(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
5797     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5798
5799     read_file_data("forcecodepage.idt", buffer);
5800     ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
5801        "Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"", buffer);
5802
5803     MsiCloseHandle(hdb);
5804     DeleteFileA(msifile);
5805     DeleteFileA("forcecodepage.idt");
5806 }
5807
5808 static void test_viewmodify_refresh(void)
5809 {
5810     MSIHANDLE hdb, hview, hrec;
5811     const char *query;
5812     char buffer[MAX_PATH];
5813     UINT r;
5814     DWORD size;
5815
5816     DeleteFile(msifile);
5817
5818     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5819     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5820
5821     query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
5822     r = run_query(hdb, 0, query);
5823     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5824
5825     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
5826     r = run_query(hdb, 0, query);
5827     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5828
5829     query = "SELECT * FROM `Table`";
5830     r = MsiDatabaseOpenView(hdb, query, &hview);
5831     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5832     r = MsiViewExecute(hview, 0);
5833     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5834
5835     r = MsiViewFetch(hview, &hrec);
5836     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5837
5838     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
5839     r = run_query(hdb, 0, query);
5840     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5841
5842     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
5843     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5844
5845     size = MAX_PATH;
5846     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
5847     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5848     ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
5849     ok(size == 2, "Expected 2, got %d\n", size);
5850
5851     r = MsiRecordGetInteger(hrec, 2);
5852     ok(r == 2, "Expected 2, got %d\n", r);
5853
5854     MsiCloseHandle(hrec);
5855     MsiViewClose(hview);
5856     MsiCloseHandle(hview);
5857
5858     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
5859     r = run_query(hdb, 0, query);
5860     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5861
5862     query = "SELECT * FROM `Table` WHERE `B` = 3";
5863     r = MsiDatabaseOpenView(hdb, query, &hview);
5864     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5865     r = MsiViewExecute(hview, 0);
5866     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5867
5868     r = MsiViewFetch(hview, &hrec);
5869     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5870
5871     query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
5872     r = run_query(hdb, 0, query);
5873     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5874
5875     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
5876     r = run_query(hdb, 0, query);
5877     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5878
5879     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
5880     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5881
5882     size = MAX_PATH;
5883     r = MsiRecordGetStringA(hrec, 1, buffer, &size);
5884     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5885     ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
5886     ok(size == 5, "Expected 5, got %d\n", size);
5887
5888     r = MsiRecordGetInteger(hrec, 2);
5889     ok(r == 2, "Expected 2, got %d\n", r);
5890
5891     MsiCloseHandle(hrec);
5892     MsiViewClose(hview);
5893     MsiCloseHandle(hview);
5894     MsiCloseHandle(hdb);
5895     DeleteFileA(msifile);
5896 }
5897
5898 static void test_where_viewmodify(void)
5899 {
5900     MSIHANDLE hdb, hview, hrec;
5901     const char *query;
5902     UINT r;
5903
5904     DeleteFile(msifile);
5905
5906     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
5907     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5908
5909     query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
5910     r = run_query(hdb, 0, query);
5911     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5912
5913     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
5914     r = run_query(hdb, 0, query);
5915     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5916
5917     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
5918     r = run_query(hdb, 0, query);
5919     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5920
5921     query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
5922     r = run_query(hdb, 0, query);
5923     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5924
5925     /* `B` = 3 doesn't match, but the view shouldn't be executed */
5926     query = "SELECT * FROM `Table` WHERE `B` = 3";
5927     r = MsiDatabaseOpenView(hdb, query, &hview);
5928     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5929
5930     hrec = MsiCreateRecord(2);
5931     MsiRecordSetInteger(hrec, 1, 7);
5932     MsiRecordSetInteger(hrec, 2, 8);
5933
5934     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
5935     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5936
5937     MsiCloseHandle(hrec);
5938     MsiViewClose(hview);
5939     MsiCloseHandle(hview);
5940
5941     query = "SELECT * FROM `Table` WHERE `A` = 7";
5942     r = MsiDatabaseOpenView(hdb, query, &hview);
5943     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5944     r = MsiViewExecute(hview, 0);
5945     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5946
5947     r = MsiViewFetch(hview, &hrec);
5948     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5949
5950     r = MsiRecordGetInteger(hrec, 1);
5951     ok(r == 7, "Expected 7, got %d\n", r);
5952
5953     r = MsiRecordGetInteger(hrec, 2);
5954     ok(r == 8, "Expected 8, got %d\n", r);
5955
5956     MsiRecordSetInteger(hrec, 2, 9);
5957
5958     r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
5959     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5960
5961     MsiCloseHandle(hrec);
5962     MsiViewClose(hview);
5963     MsiCloseHandle(hview);
5964
5965     query = "SELECT * FROM `Table` WHERE `A` = 7";
5966     r = MsiDatabaseOpenView(hdb, query, &hview);
5967     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5968     r = MsiViewExecute(hview, 0);
5969     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5970
5971     r = MsiViewFetch(hview, &hrec);
5972     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5973
5974     r = MsiRecordGetInteger(hrec, 1);
5975     ok(r == 7, "Expected 7, got %d\n", r);
5976
5977     r = MsiRecordGetInteger(hrec, 2);
5978     ok(r == 9, "Expected 9, got %d\n", r);
5979
5980     query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
5981     r = run_query(hdb, 0, query);
5982     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5983
5984     r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
5985     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
5986
5987     r = MsiRecordGetInteger(hrec, 1);
5988     ok(r == 7, "Expected 7, got %d\n", r);
5989
5990     r = MsiRecordGetInteger(hrec, 2);
5991     ok(r == 10, "Expected 10, got %d\n", r);
5992
5993     MsiCloseHandle(hrec);
5994     MsiViewClose(hview);
5995     MsiCloseHandle(hview);
5996     MsiCloseHandle(hdb);
5997 }
5998
5999 static BOOL create_storage(LPCSTR name)
6000 {
6001     WCHAR nameW[MAX_PATH];
6002     IStorage *stg;
6003     IStream *stm;
6004     HRESULT hr;
6005     DWORD count;
6006     BOOL res = FALSE;
6007
6008     MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
6009     hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
6010                           STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
6011     if (FAILED(hr))
6012         return FALSE;
6013
6014     hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
6015                                0, 0, &stm);
6016     if (FAILED(hr))
6017         goto done;
6018
6019     hr = IStream_Write(stm, "stgdata", 8, &count);
6020     if (SUCCEEDED(hr))
6021         res = TRUE;
6022
6023 done:
6024     IStream_Release(stm);
6025     IStorage_Release(stg);
6026
6027     return res;
6028 }
6029
6030 static void test_storages_table(void)
6031 {
6032     MSIHANDLE hdb, hview, hrec;
6033     IStorage *stg, *inner;
6034     IStream *stm;
6035     char file[MAX_PATH];
6036     char buf[MAX_PATH];
6037     WCHAR name[MAX_PATH];
6038     LPCSTR query;
6039     HRESULT hr;
6040     DWORD size;
6041     UINT r;
6042
6043     hdb = create_db();
6044     ok(hdb, "failed to create db\n");
6045
6046     r = MsiDatabaseCommit(hdb);
6047     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
6048
6049     MsiCloseHandle(hdb);
6050
6051     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb);
6052     ok(r == ERROR_SUCCESS , "Failed to open database\n");
6053
6054     /* check the column types */
6055     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
6056     ok(hrec, "failed to get column info hrecord\n");
6057     todo_wine
6058     {
6059         ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
6060         ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
6061     }
6062
6063     MsiCloseHandle(hrec);
6064
6065     /* now try the names */
6066     hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
6067     ok(hrec, "failed to get column info hrecord\n");
6068     todo_wine
6069     {
6070         ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
6071         ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
6072     }
6073
6074     MsiCloseHandle(hrec);
6075
6076     create_storage("storage.bin");
6077
6078     hrec = MsiCreateRecord(2);
6079     MsiRecordSetString(hrec, 1, "stgname");
6080
6081     r = MsiRecordSetStream(hrec, 2, "storage.bin");
6082     ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
6083
6084     DeleteFileA("storage.bin");
6085
6086     query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
6087     r = MsiDatabaseOpenView(hdb, query, &hview);
6088     todo_wine
6089     {
6090         ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
6091     }
6092
6093     r = MsiViewExecute(hview, hrec);
6094     todo_wine
6095     {
6096         ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
6097     }
6098
6099     MsiCloseHandle(hrec);
6100     MsiViewClose(hview);
6101     MsiCloseHandle(hview);
6102
6103     query = "SELECT `Name`, `Data` FROM `_Storages`";
6104     r = MsiDatabaseOpenView(hdb, query, &hview);
6105     todo_wine
6106     {
6107         ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
6108     }
6109
6110     r = MsiViewExecute(hview, 0);
6111     todo_wine
6112     {
6113         ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
6114     }
6115
6116     r = MsiViewFetch(hview, &hrec);
6117     todo_wine
6118     {
6119         ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
6120     }
6121
6122     size = MAX_PATH;
6123     r = MsiRecordGetString(hrec, 1, file, &size);
6124     todo_wine
6125     {
6126         ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
6127         ok(!lstrcmp(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
6128     }
6129
6130     size = MAX_PATH;
6131     lstrcpyA(buf, "apple");
6132     r = MsiRecordReadStream(hrec, 2, buf, &size);
6133     ok(!lstrcmp(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
6134     todo_wine
6135     {
6136         ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
6137         ok(size == 0, "Expected 0, got %d\n", size);
6138     }
6139
6140     MsiCloseHandle(hrec);
6141
6142     r = MsiViewFetch(hview, &hrec);
6143     todo_wine
6144     {
6145         ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
6146     }
6147
6148     MsiViewClose(hview);
6149     MsiCloseHandle(hview);
6150
6151     MsiDatabaseCommit(hdb);
6152     MsiCloseHandle(hdb);
6153
6154     MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
6155     hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
6156                         STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
6157     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6158     ok(stg != NULL, "Expected non-NULL storage\n");
6159
6160     MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
6161     hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
6162                               NULL, 0, &inner);
6163     todo_wine
6164     {
6165         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6166         ok(inner != NULL, "Expected non-NULL storage\n");
6167     }
6168
6169     /* FIXME: remove when wine is fixed */
6170     if (inner)
6171     {
6172         MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
6173         hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
6174         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
6175         ok(stm != NULL, "Expected non-NULL stream\n");
6176
6177         hr = IStream_Read(stm, buf, MAX_PATH, &size);
6178         ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
6179         ok(size == 8, "Expected 8, got %d\n", size);
6180         ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
6181
6182         IStream_Release(stm);
6183         IStorage_Release(inner);
6184     }
6185
6186     IStorage_Release(stg);
6187     DeleteFileA(msifile);
6188 }
6189
6190 START_TEST(db)
6191 {
6192     test_msidatabase();
6193     test_msiinsert();
6194     test_msidecomposedesc();
6195     test_msibadqueries();
6196     test_viewmodify();
6197     test_viewgetcolumninfo();
6198     test_getcolinfo();
6199     test_msiexport();
6200     test_longstrings();
6201     test_streamtable();
6202     test_where();
6203     test_msiimport();
6204     test_markers();
6205     test_handle_limit();
6206     test_try_transform();
6207     test_join();
6208     test_temporary_table();
6209     test_alter();
6210     test_integers();
6211     test_update();
6212     test_special_tables();
6213     test_select_markers();
6214     test_viewmodify_update();
6215     test_stringtable();
6216     test_viewmodify_delete();
6217     test_defaultdatabase();
6218     test_order();
6219     test_viewmodify_delete_temporary();
6220     test_deleterow();
6221     test_quotes();
6222     test_carriagereturn();
6223     test_noquotes();
6224     test_forcecodepage();
6225     test_viewmodify_refresh();
6226     test_where_viewmodify();
6227     test_storages_table();
6228 }