git.oblomov.eu Git - wine/blob - 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     const char *query;
 702     char buffer[0x100];
 703     DWORD sz;
 704
 705     DeleteFile(msifile);
 706
 707     /* just MsiOpenDatabase should not create a file */
 708     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 709     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 710
 711     query = "CREATE TABLE `phone` ( "
 712             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 713             "PRIMARY KEY `id`)";
 714     r = run_query( hdb, 0, query );
 715     ok(r == ERROR_SUCCESS, "query failed\n");
 716
 717     /* check what the error function reports without doing anything */
 718     sz = 0;
 719     /* passing NULL as the 3rd param make function to crash on older platforms */
 720     r = MsiViewGetError( 0, NULL, &sz );
 721     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 722
 723     /* open a view */
 724     query = "SELECT * FROM `phone`";
 725     r = MsiDatabaseOpenView(hdb, query, &hview);
 726     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 727
 728     /* see what happens with a good hview and bad args */
 729     r = MsiViewGetError( hview, NULL, NULL );
 730     ok(r == MSIDBERROR_INVALIDARG || r == MSIDBERROR_NOERROR,
 731        "MsiViewGetError returns %u (expected -3)\n", r);
 732     r = MsiViewGetError( hview, buffer, NULL );
 733     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 734
 735     /* see what happens with a zero length buffer */
 736     sz = 0;
 737     buffer[0] = 'x';
 738     r = MsiViewGetError( hview, buffer, &sz );
 739     ok(r == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 740     ok(buffer[0] == 'x', "buffer cleared\n");
 741     ok(sz == 0, "size not zero\n");
 742
 743     /* ok this one is strange */
 744     sz = 0;
 745     r = MsiViewGetError( hview, NULL, &sz );
 746     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 747     ok(sz == 0, "size not zero\n");
 748
 749     /* see if it really has an error */
 750     sz = sizeof buffer;
 751     buffer[0] = 'x';
 752     r = MsiViewGetError( hview, buffer, &sz );
 753     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 754     ok(buffer[0] == 0, "buffer not cleared\n");
 755     ok(sz == 0, "size not zero\n");
 756
 757     r = MsiViewExecute(hview, 0);
 758     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 759
 760     /* try some invalid records */
 761     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 762     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 763     r = MsiViewModify(hview, -1, 0 );
 764     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 765
 766     /* try an small record */
 767     hrec = MsiCreateRecord(1);
 768     r = MsiViewModify(hview, -1, hrec );
 769     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 770
 771     r = MsiCloseHandle(hrec);
 772     ok(r == ERROR_SUCCESS, "failed to close record\n");
 773
 774     /* insert a valid record */
 775     hrec = MsiCreateRecord(3);
 776
 777     r = MsiRecordSetInteger(hrec, 2, 1);
 778     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 779     r = MsiRecordSetString(hrec, 2, "bob");
 780     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 781     r = MsiRecordSetString(hrec, 3, "7654321");
 782     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 783
 784     r = MsiViewExecute(hview, 0);
 785     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 786     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 787     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 788
 789     /* insert the same thing again */
 790     r = MsiViewExecute(hview, 0);
 791     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 792
 793     /* should fail ... */
 794     todo_wine {
 795     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 796     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 797     }
 798
 799     r = MsiCloseHandle(hrec);
 800     ok(r == ERROR_SUCCESS, "failed to close record\n");
 801
 802     r = MsiViewClose(hview);
 803     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 804     r = MsiCloseHandle(hview);
 805     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 806
 807     r = MsiCloseHandle( hdb );
 808     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
 809 }
 810
 811 static MSIHANDLE create_db(void)
 812 {
 813     MSIHANDLE hdb = 0;
 814     UINT res;
 815
 816     DeleteFile(msifile);
 817
 818     /* create an empty database */
 819     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
 820     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
 821     if( res != ERROR_SUCCESS )
 822         return hdb;
 823
 824     res = MsiDatabaseCommit( hdb );
 825     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 826
 827     return hdb;
 828 }
 829
 830 static void test_getcolinfo(void)
 831 {
 832     MSIHANDLE hdb, hview = 0, rec = 0;
 833     UINT r;
 834     DWORD sz;
 835     char buffer[0x20];
 836
 837     /* create an empty db */
 838     hdb = create_db();
 839     ok( hdb, "failed to create db\n");
 840
 841     /* tables should be present */
 842     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
 843     ok( r == ERROR_SUCCESS, "failed to open query\n");
 844
 845     r = MsiViewExecute(hview, 0);
 846     ok( r == ERROR_SUCCESS, "failed to execute query\n");
 847
 848     /* check that NAMES works */
 849     rec = 0;
 850     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
 851     ok( r == ERROR_SUCCESS, "failed to get names\n");
 852     sz = sizeof buffer;
 853     r = MsiRecordGetString(rec, 1, buffer, &sz );
 854     ok( r == ERROR_SUCCESS, "failed to get string\n");
 855     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
 856     r = MsiCloseHandle( rec );
 857     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 858
 859     /* check that TYPES works */
 860     rec = 0;
 861     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
 862     ok( r == ERROR_SUCCESS, "failed to get names\n");
 863     sz = sizeof buffer;
 864     r = MsiRecordGetString(rec, 1, buffer, &sz );
 865     ok( r == ERROR_SUCCESS, "failed to get string\n");
 866     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
 867     r = MsiCloseHandle( rec );
 868     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 869
 870     /* check that invalid values fail */
 871     rec = 0;
 872     r = MsiViewGetColumnInfo( hview, 100, &rec );
 873     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 874     ok( rec == 0, "returned a record\n");
 875
 876     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
 877     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 878
 879     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
 880     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
 881
 882     r = MsiViewClose(hview);
 883     ok( r == ERROR_SUCCESS, "failed to close view\n");
 884     r = MsiCloseHandle(hview);
 885     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
 886     r = MsiCloseHandle(hdb);
 887     ok( r == ERROR_SUCCESS, "failed to close database\n");
 888 }
 889
 890 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
 891 {
 892     MSIHANDLE hview = 0, rec = 0;
 893     UINT r;
 894
 895     r = MsiDatabaseOpenView(hdb, query, &hview);
 896     if( r != ERROR_SUCCESS )
 897         return r;
 898
 899     r = MsiViewExecute(hview, 0);
 900     if( r == ERROR_SUCCESS )
 901     {
 902         MsiViewGetColumnInfo( hview, type, &rec );
 903         MsiViewClose(hview);
 904     }
 905     MsiCloseHandle(hview);
 906     return rec;
 907 }
 908
 909 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
 910 {
 911     MSIHANDLE hview = 0, rec = 0;
 912     UINT r, type = 0;
 913     char query[0x100];
 914
 915     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
 916
 917     r = MsiDatabaseOpenView(hdb, query, &hview);
 918     if( r != ERROR_SUCCESS )
 919         return r;
 920
 921     r = MsiViewExecute(hview, 0);
 922     if( r == ERROR_SUCCESS )
 923     {
 924         while (1)
 925         {
 926             r = MsiViewFetch( hview, &rec );
 927             if( r != ERROR_SUCCESS)
 928                 break;
 929             r = MsiRecordGetInteger( rec, 2 );
 930             if (r == field)
 931                 type = MsiRecordGetInteger( rec, 4 );
 932             MsiCloseHandle( rec );
 933         }
 934
 935         MsiViewClose(hview);
 936     }
 937     MsiCloseHandle(hview);
 938     return type;
 939 }
 940
 941 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
 942 {
 943     CHAR buffer[0x20];
 944     UINT r;
 945     DWORD sz;
 946
 947     sz = sizeof buffer;
 948     r = MsiRecordGetString( rec, field, buffer, &sz );
 949     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
 950 }
 951
 952 static void test_viewgetcolumninfo(void)
 953 {
 954     MSIHANDLE hdb = 0, rec;
 955     UINT r;
 956
 957     hdb = create_db();
 958     ok( hdb, "failed to create db\n");
 959
 960     r = run_query( hdb, 0,
 961             "CREATE TABLE `Properties` "
 962             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
 963     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 964
 965     /* check the column types */
 966     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
 967     ok( rec, "failed to get column info record\n" );
 968
 969     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 970     ok( check_record( rec, 2, "S1"), "wrong record type\n");
 971
 972     MsiCloseHandle( rec );
 973
 974     /* check the type in _Columns */
 975     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
 976     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
 977
 978     /* now try the names */
 979     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
 980     ok( rec, "failed to get column info record\n" );
 981
 982     ok( check_record( rec, 1, "Property"), "wrong record type\n");
 983     ok( check_record( rec, 2, "Value"), "wrong record type\n");
 984
 985     MsiCloseHandle( rec );
 986
 987     r = run_query( hdb, 0,
 988             "CREATE TABLE `Binary` "
 989             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
 990     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 991
 992     /* check the column types */
 993     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
 994     ok( rec, "failed to get column info record\n" );
 995
 996     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 997     ok( check_record( rec, 2, "V0"), "wrong record type\n");
 998
 999     MsiCloseHandle( rec );
1000
1001     /* check the type in _Columns */
1002     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
1003     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
1004
1005     /* now try the names */
1006     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
1007     ok( rec, "failed to get column info record\n" );
1008
1009     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1010     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1011     MsiCloseHandle( rec );
1012
1013     r = run_query( hdb, 0,
1014             "CREATE TABLE `UIText` "
1015             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
1016     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1017
1018     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
1019     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
1020
1021     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
1022     ok( rec, "failed to get column info record\n" );
1023     ok( check_record( rec, 1, "Key"), "wrong record type\n");
1024     ok( check_record( rec, 2, "Text"), "wrong record type\n");
1025     MsiCloseHandle( rec );
1026
1027     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
1028     ok( rec, "failed to get column info record\n" );
1029     ok( check_record( rec, 1, "s72"), "wrong record type\n");
1030     ok( check_record( rec, 2, "L255"), "wrong record type\n");
1031     MsiCloseHandle( rec );
1032
1033     MsiCloseHandle( hdb );
1034 }
1035
1036 static void test_msiexport(void)
1037 {
1038     MSIHANDLE hdb = 0, hview = 0;
1039     UINT r;
1040     const char *query;
1041     char path[MAX_PATH];
1042     const char file[] = "phone.txt";
1043     HANDLE handle;
1044     char buffer[0x100];
1045     DWORD length;
1046     const char expected[] =
1047         "id\tname\tnumber\r\n"
1048         "I2\tS32\tS32\r\n"
1049         "phone\tid\r\n"
1050         "1\tAbe\t8675309\r\n";
1051
1052     DeleteFile(msifile);
1053
1054     /* just MsiOpenDatabase should not create a file */
1055     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1056     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1057
1058     /* create a table */
1059     query = "CREATE TABLE `phone` ( "
1060             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1061             "PRIMARY KEY `id`)";
1062     r = MsiDatabaseOpenView(hdb, query, &hview);
1063     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1064     r = MsiViewExecute(hview, 0);
1065     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1066     r = MsiViewClose(hview);
1067     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1068     r = MsiCloseHandle(hview);
1069     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1070
1071     /* insert a value into it */
1072     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1073         "VALUES('1', 'Abe', '8675309')";
1074     r = MsiDatabaseOpenView(hdb, query, &hview);
1075     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1076     r = MsiViewExecute(hview, 0);
1077     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1078     r = MsiViewClose(hview);
1079     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1080     r = MsiCloseHandle(hview);
1081     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1082
1083     GetCurrentDirectory(MAX_PATH, path);
1084
1085     r = MsiDatabaseExport(hdb, "phone", path, file);
1086     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1087
1088     MsiCloseHandle(hdb);
1089
1090     lstrcat(path, "\\");
1091     lstrcat(path, file);
1092
1093     /* check the data that was written */
1094     length = 0;
1095     memset(buffer, 0, sizeof buffer);
1096     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1097     if (handle != INVALID_HANDLE_VALUE)
1098     {
1099         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1100         CloseHandle(handle);
1101         DeleteFile(path);
1102     }
1103     else
1104         ok(0, "failed to open file %s\n", path);
1105
1106     ok( length == strlen(expected), "length of data wrong\n");
1107     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
1108     DeleteFile(msifile);
1109 }
1110
1111 static void test_longstrings(void)
1112 {
1113     const char insert_query[] =
1114         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1115     char *str;
1116     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1117     DWORD len;
1118     UINT r;
1119     const DWORD STRING_LENGTH = 0x10005;
1120
1121     DeleteFile(msifile);
1122     /* just MsiOpenDatabase should not create a file */
1123     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1124     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1125
1126     /* create a table */
1127     r = try_query( hdb,
1128         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1129     ok(r == ERROR_SUCCESS, "query failed\n");
1130
1131     /* try a insert a very long string */
1132     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1133     len = strchr(insert_query, 'Z') - insert_query;
1134     strcpy(str, insert_query);
1135     memset(str+len, 'Z', STRING_LENGTH);
1136     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1137     r = try_query( hdb, str );
1138     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1139
1140     HeapFree(GetProcessHeap(), 0, str);
1141
1142     MsiDatabaseCommit(hdb);
1143     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1144     MsiCloseHandle(hdb);
1145
1146     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
1147     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1148
1149     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
1150     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1151
1152     r = MsiViewExecute(hview, 0);
1153     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1154
1155     r = MsiViewFetch(hview, &hrec);
1156     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1157
1158     MsiCloseHandle(hview);
1159
1160     r = MsiRecordGetString(hrec, 2, NULL, &len);
1161     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1162     ok(len == STRING_LENGTH, "string length wrong\n");
1163
1164     MsiCloseHandle(hrec);
1165     MsiCloseHandle(hdb);
1166     DeleteFile(msifile);
1167 }
1168
1169 static void create_file(const CHAR *name)
1170 {
1171     HANDLE file;
1172     DWORD written;
1173
1174     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1175     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
1176     WriteFile(file, name, strlen(name), &written, NULL);
1177     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1178     CloseHandle(file);
1179 }
1180
1181 static void test_streamtable(void)
1182 {
1183     MSIHANDLE hdb = 0, rec, view;
1184     char file[MAX_PATH];
1185     char buf[MAX_PATH];
1186     DWORD size;
1187     UINT r;
1188
1189     hdb = create_db();
1190     ok( hdb, "failed to create db\n");
1191
1192     r = run_query( hdb, 0,
1193             "CREATE TABLE `Properties` "
1194             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1195     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1196
1197     r = run_query( hdb, 0,
1198             "INSERT INTO `Properties` "
1199             "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
1200     ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
1201
1202     r = MsiDatabaseCommit( hdb );
1203     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1204
1205     MsiCloseHandle( hdb );
1206
1207     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
1208     ok( r == ERROR_SUCCESS , "Failed to open database\n" );
1209
1210     /* check the column types */
1211     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1212     ok( rec, "failed to get column info record\n" );
1213
1214     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1215     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1216
1217     MsiCloseHandle( rec );
1218
1219     /* now try the names */
1220     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1221     ok( rec, "failed to get column info record\n" );
1222
1223     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1224     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1225
1226     MsiCloseHandle( rec );
1227
1228     /* insert a file into the _Streams table */
1229     create_file( "test.txt" );
1230
1231     rec = MsiCreateRecord( 2 );
1232     MsiRecordSetString( rec, 1, "data" );
1233
1234     r = MsiRecordSetStream( rec, 2, "test.txt" );
1235     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1236
1237     DeleteFile("test.txt");
1238
1239     r = MsiDatabaseOpenView( hdb,
1240             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1241     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1242
1243     r = MsiViewExecute( view, rec );
1244     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1245
1246     MsiCloseHandle( rec );
1247     MsiCloseHandle( view );
1248
1249     r = MsiDatabaseOpenView( hdb,
1250             "SELECT `Name`, `Data` FROM `_Streams`", &view );
1251     ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1252
1253     r = MsiViewExecute( view, 0 );
1254     ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1255
1256     r = MsiViewFetch( view, &rec );
1257     ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1258
1259     size = MAX_PATH;
1260     r = MsiRecordGetString( rec, 1, file, &size );
1261     ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1262     ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1263
1264     size = MAX_PATH;
1265     memset(buf, 0, MAX_PATH);
1266     r = MsiRecordReadStream( rec, 2, buf, &size );
1267     ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1268     ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1269
1270     MsiCloseHandle( rec );
1271
1272     r = MsiViewFetch( view, &rec );
1273     ok( r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1274
1275     MsiCloseHandle( view );
1276     MsiCloseHandle( hdb );
1277     DeleteFile(msifile);
1278 }
1279
1280 static void test_where(void)
1281 {
1282     MSIHANDLE hdb = 0, rec, view;
1283     LPCSTR query;
1284     UINT r;
1285     DWORD size;
1286     CHAR buf[MAX_PATH];
1287     UINT count;
1288
1289     hdb = create_db();
1290     ok( hdb, "failed to create db\n");
1291
1292     r = run_query( hdb, 0,
1293             "CREATE TABLE `Media` ("
1294             "`DiskId` SHORT NOT NULL, "
1295             "`LastSequence` LONG, "
1296             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1297             "`Cabinet` CHAR(255), "
1298             "`VolumeLabel` CHAR(32), "
1299             "`Source` CHAR(72) "
1300             "PRIMARY KEY `DiskId`)" );
1301     ok( r == S_OK, "cannot create Media table: %d\n", r );
1302
1303     r = run_query( hdb, 0, "INSERT INTO `Media` "
1304             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1305             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1306     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1307
1308     r = run_query( hdb, 0, "INSERT INTO `Media` "
1309             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1310             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1311     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1312
1313     r = run_query( hdb, 0, "INSERT INTO `Media` "
1314             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1315             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1316     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1317
1318     query = "SELECT * FROM `Media`";
1319     r = do_query(hdb, query, &rec);
1320     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1321     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1322     MsiCloseHandle( rec );
1323
1324     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1325     r = do_query(hdb, query, &rec);
1326     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1327     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1328
1329     r = MsiRecordGetInteger(rec, 1);
1330     ok( 2 == r, "field wrong\n");
1331     r = MsiRecordGetInteger(rec, 2);
1332     ok( 1 == r, "field wrong\n");
1333     MsiCloseHandle( rec );
1334
1335     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
1336     r = MsiDatabaseOpenView(hdb, query, &view);
1337     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1338
1339     r = MsiViewExecute(view, 0);
1340     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1341
1342     r = MsiViewFetch(view, &rec);
1343     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1344
1345     count = MsiRecordGetFieldCount( rec );
1346     ok( count == 1, "Expected 1 record fields, got %d\n", count );
1347
1348     size = MAX_PATH;
1349     r = MsiRecordGetString( rec, 1, buf, &size );
1350     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1351     ok( !lstrcmp( buf, "2" ),
1352         "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
1353     MsiCloseHandle( rec );
1354
1355     r = MsiViewFetch(view, &rec);
1356     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1357
1358     size = MAX_PATH;
1359     r = MsiRecordGetString( rec, 1, buf, &size );
1360     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1361     ok( !lstrcmp( buf, "3" ),
1362         "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
1363     MsiCloseHandle( rec );
1364
1365     r = MsiViewFetch(view, &rec);
1366     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1367
1368     MsiViewClose(view);
1369     MsiCloseHandle(view);
1370
1371     MsiCloseHandle( rec );
1372
1373     rec = 0;
1374     query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
1375     r = do_query(hdb, query, &rec);
1376     ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
1377     MsiCloseHandle( rec );
1378
1379     MsiCloseHandle( hdb );
1380     DeleteFile(msifile);
1381 }
1382
1383 static CHAR CURR_DIR[MAX_PATH];
1384
1385 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1386                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1387                                 "TestTable\tFirstPrimaryColumn\n"
1388                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1389
1390 static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
1391                                   "s255\ts255\n"
1392                                   "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
1393                                   "papaya\tleaf\n"
1394                                   "papaya\tflower\n";
1395
1396 static void write_file(const CHAR *filename, const char *data, int data_size)
1397 {
1398     DWORD size;
1399
1400     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1401                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1402
1403     WriteFile(hf, data, data_size, &size, NULL);
1404     CloseHandle(hf);
1405 }
1406
1407 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1408 {
1409     UINT r;
1410
1411     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1412     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1413     DeleteFileA("temp_file");
1414
1415     return r;
1416 }
1417
1418 static void test_msiimport(void)
1419 {
1420     MSIHANDLE hdb, view, rec;
1421     LPCSTR query;
1422     UINT r, count;
1423     signed int i;
1424
1425     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1426
1427     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1428     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1429
1430     r = add_table_to_db(hdb, test_data);
1431     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1432
1433     r = add_table_to_db(hdb, two_primary);
1434     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1435
1436     query = "SELECT * FROM `TestTable`";
1437     r = MsiDatabaseOpenView(hdb, query, &view);
1438     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1439
1440     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1441     count = MsiRecordGetFieldCount(rec);
1442     ok(count == 9, "Expected 9, got %d\n", count);
1443     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1444     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1445     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1446     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1447     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1448     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1449     ok(check_record(rec, 7, "String"), "Expected String\n");
1450     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1451     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1452     MsiCloseHandle(rec);
1453
1454     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1455     count = MsiRecordGetFieldCount(rec);
1456     ok(count == 9, "Expected 9, got %d\n", count);
1457     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1458     ok(check_record(rec, 2, "i2"), "Expected i2\n");
1459     ok(check_record(rec, 3, "i2"), "Expected i2\n");
1460     ok(check_record(rec, 4, "I2"), "Expected I2\n");
1461     ok(check_record(rec, 5, "i4"), "Expected i4\n");
1462     ok(check_record(rec, 6, "I4"), "Expected I4\n");
1463     ok(check_record(rec, 7, "S255"), "Expected S255\n");
1464     ok(check_record(rec, 8, "S0"), "Expected S0\n");
1465     ok(check_record(rec, 9, "s0"), "Expected s0\n");
1466     MsiCloseHandle(rec);
1467
1468     query = "SELECT * FROM `TestTable`";
1469     r = do_query(hdb, query, &rec);
1470     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1471     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1472     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1473     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1474     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1475
1476     i = MsiRecordGetInteger(rec, 2);
1477     ok(i == 5, "Expected 5, got %d\n", i);
1478
1479     i = MsiRecordGetInteger(rec, 3);
1480     ok(i == 2, "Expected 2, got %d\n", i);
1481
1482     i = MsiRecordGetInteger(rec, 4);
1483     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
1484
1485     i = MsiRecordGetInteger(rec, 5);
1486     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1487
1488     i = MsiRecordGetInteger(rec, 6);
1489     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1490
1491     MsiCloseHandle(rec);
1492     MsiCloseHandle(view);
1493
1494     query = "SELECT * FROM `TwoPrimary`";
1495     r = MsiDatabaseOpenView(hdb, query, &view);
1496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1497
1498     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1499     count = MsiRecordGetFieldCount(rec);
1500     ok(count == 2, "Expected 2, got %d\n", count);
1501     ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
1502     ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
1503
1504     MsiCloseHandle(rec);
1505
1506     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1507     count = MsiRecordGetFieldCount(rec);
1508     ok(count == 2, "Expected 2, got %d\n", count);
1509     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1510     ok(check_record(rec, 2, "s255"), "Expected s255\n");
1511     MsiCloseHandle(rec);
1512
1513     r = MsiViewExecute(view, 0);
1514     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1515
1516     r = MsiViewFetch(view, &rec);
1517     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1518
1519     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1520     ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
1521
1522     MsiCloseHandle(rec);
1523
1524     r = MsiViewFetch(view, &rec);
1525     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1526
1527     ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
1528     ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
1529
1530     MsiCloseHandle(rec);
1531
1532     r = MsiViewFetch(view, &rec);
1533     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1534
1535     r = MsiViewClose(view);
1536     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1537
1538     MsiCloseHandle(view);
1539     MsiCloseHandle(hdb);
1540     DeleteFileA(msifile);
1541 }
1542
1543 static void test_markers(void)
1544 {
1545     MSIHANDLE hdb, rec;
1546     LPCSTR query;
1547     UINT r;
1548
1549     hdb = create_db();
1550     ok( hdb, "failed to create db\n");
1551
1552     rec = MsiCreateRecord(3);
1553     MsiRecordSetString(rec, 1, "Table");
1554     MsiRecordSetString(rec, 2, "Apples");
1555     MsiRecordSetString(rec, 3, "Oranges");
1556
1557     /* try a legit create */
1558     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1559     r = run_query(hdb, 0, query);
1560     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1561     MsiCloseHandle(rec);
1562
1563     /* try table name as marker */
1564     rec = MsiCreateRecord(1);
1565     MsiRecordSetString(rec, 1, "Fable");
1566     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1567     r = run_query(hdb, rec, query);
1568     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1569
1570     /* verify that we just created a table called '?', not 'Fable' */
1571     r = try_query(hdb, "SELECT * from `Fable`");
1572     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1573
1574     r = try_query(hdb, "SELECT * from `?`");
1575     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1576
1577     /* try table name as marker without backticks */
1578     MsiRecordSetString(rec, 1, "Mable");
1579     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1580     r = run_query(hdb, rec, query);
1581     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1582
1583     /* try one column name as marker */
1584     MsiRecordSetString(rec, 1, "One");
1585     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1586     r = run_query(hdb, rec, query);
1587     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1588     MsiCloseHandle(rec);
1589
1590     /* try column names as markers */
1591     rec = MsiCreateRecord(2);
1592     MsiRecordSetString(rec, 1, "One");
1593     MsiRecordSetString(rec, 2, "Two");
1594     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1595     r = run_query(hdb, rec, query);
1596     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1597     MsiCloseHandle(rec);
1598
1599     /* try names with backticks */
1600     rec = MsiCreateRecord(3);
1601     MsiRecordSetString(rec, 1, "One");
1602     MsiRecordSetString(rec, 2, "Two");
1603     MsiRecordSetString(rec, 3, "One");
1604     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1605     r = run_query(hdb, rec, query);
1606     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1607
1608     /* try names with backticks, minus definitions */
1609     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1610     r = run_query(hdb, rec, query);
1611     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1612
1613     /* try names without backticks */
1614     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1615     r = run_query(hdb, rec, query);
1616     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1617     MsiCloseHandle(rec);
1618
1619     /* try one long marker */
1620     rec = MsiCreateRecord(1);
1621     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1622     query = "CREATE TABLE `Mable` ( ? )";
1623     r = run_query(hdb, rec, query);
1624     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1625     MsiCloseHandle(rec);
1626
1627     /* try all names as markers */
1628     rec = MsiCreateRecord(4);
1629     MsiRecordSetString(rec, 1, "Mable");
1630     MsiRecordSetString(rec, 2, "One");
1631     MsiRecordSetString(rec, 3, "Two");
1632     MsiRecordSetString(rec, 4, "One");
1633     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1634     r = run_query(hdb, rec, query);
1635     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1636     MsiCloseHandle(rec);
1637
1638     /* try a legit insert */
1639     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1640     r = run_query(hdb, 0, query);
1641     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1642
1643     r = try_query(hdb, "SELECT * from `Table`");
1644     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1645
1646     /* try values as markers */
1647     rec = MsiCreateRecord(2);
1648     MsiRecordSetInteger(rec, 1, 4);
1649     MsiRecordSetString(rec, 2, "hi");
1650     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1651     r = run_query(hdb, rec, query);
1652     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1653     MsiCloseHandle(rec);
1654
1655     /* try column names and values as markers */
1656     rec = MsiCreateRecord(4);
1657     MsiRecordSetString(rec, 1, "One");
1658     MsiRecordSetString(rec, 2, "Two");
1659     MsiRecordSetInteger(rec, 3, 5);
1660     MsiRecordSetString(rec, 4, "hi");
1661     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1662     r = run_query(hdb, rec, query);
1663     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1664     MsiCloseHandle(rec);
1665
1666     /* try column names as markers */
1667     rec = MsiCreateRecord(2);
1668     MsiRecordSetString(rec, 1, "One");
1669     MsiRecordSetString(rec, 2, "Two");
1670     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1671     r = run_query(hdb, rec, query);
1672     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1673     MsiCloseHandle(rec);
1674
1675     /* try table name as a marker */
1676     rec = MsiCreateRecord(1);
1677     MsiRecordSetString(rec, 1, "Table");
1678     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1679     r = run_query(hdb, rec, query);
1680     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1681     MsiCloseHandle(rec);
1682
1683     /* try table name and values as markers */
1684     rec = MsiCreateRecord(3);
1685     MsiRecordSetString(rec, 1, "Table");
1686     MsiRecordSetInteger(rec, 2, 10);
1687     MsiRecordSetString(rec, 3, "haha");
1688     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1689     r = run_query(hdb, rec, query);
1690     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1691     MsiCloseHandle(rec);
1692
1693     /* try all markers */
1694     rec = MsiCreateRecord(5);
1695     MsiRecordSetString(rec, 1, "Table");
1696     MsiRecordSetString(rec, 1, "One");
1697     MsiRecordSetString(rec, 1, "Two");
1698     MsiRecordSetInteger(rec, 2, 10);
1699     MsiRecordSetString(rec, 3, "haha");
1700     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1701     r = run_query(hdb, rec, query);
1702     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1703     MsiCloseHandle(rec);
1704
1705     /* insert an integer as a string */
1706     rec = MsiCreateRecord(2);
1707     MsiRecordSetString(rec, 1, "11");
1708     MsiRecordSetString(rec, 2, "hi");
1709     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1710     r = run_query(hdb, rec, query);
1711     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1712     MsiCloseHandle(rec);
1713
1714     /* leave off the '' for the string */
1715     rec = MsiCreateRecord(2);
1716     MsiRecordSetInteger(rec, 1, 12);
1717     MsiRecordSetString(rec, 2, "hi");
1718     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
1719     r = run_query(hdb, rec, query);
1720     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1721     MsiCloseHandle(rec);
1722
1723     MsiCloseHandle(hdb);
1724     DeleteFileA(msifile);
1725 }
1726
1727 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
1728 static void test_handle_limit(void)
1729 {
1730     int i;
1731     MSIHANDLE hdb;
1732     MSIHANDLE hviews[MY_NVIEWS];
1733     UINT r;
1734
1735     /* create an empty db */
1736     hdb = create_db();
1737     ok( hdb, "failed to create db\n");
1738
1739     memset(hviews, 0, sizeof(hviews));
1740
1741     for (i=0; i<MY_NVIEWS; i++) {
1742         static char szQueryBuf[256] = "SELECT * from `_Tables`";
1743         hviews[i] = 0xdeadbeeb;
1744         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
1745         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
1746             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
1747             break;
1748     }
1749
1750     ok( i == MY_NVIEWS, "problem opening views\n");
1751
1752     for (i=0; i<MY_NVIEWS; i++) {
1753         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
1754             r = MsiCloseHandle(hviews[i]);
1755             if (r != ERROR_SUCCESS)
1756                 break;
1757         }
1758     }
1759
1760     ok( i == MY_NVIEWS, "problem closing views\n");
1761
1762     r = MsiCloseHandle(hdb);
1763     ok( r == ERROR_SUCCESS, "failed to close database\n");
1764 }
1765
1766 static void generate_transform(void)
1767 {
1768     MSIHANDLE hdb1, hdb2, hrec;
1769     LPCSTR query;
1770     UINT r;
1771
1772     /* start with two identical databases */
1773     CopyFile(msifile2, msifile, FALSE);
1774
1775     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb1 );
1776     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1777
1778     r = MsiDatabaseCommit( hdb1 );
1779     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1780
1781     r = MsiOpenDatabase(msifile2, MSIDBOPEN_READONLY, &hdb2 );
1782     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1783
1784     /* the transform between two identical database should be empty */
1785     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1786     todo_wine {
1787     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
1788     }
1789
1790     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
1791     r = run_query(hdb1, 0, query);
1792     ok(r == ERROR_SUCCESS, "failed to add table\n");
1793
1794     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
1795     r = run_query(hdb1, 0, query);
1796     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
1797
1798     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
1799     r = run_query(hdb1, 0, query);
1800     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
1801
1802     query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
1803     r = run_query(hdb1, 0, query);
1804     ok(r == ERROR_SUCCESS, "failed to modify row\n");
1805
1806     query = "DELETE FROM `MOO` WHERE `NOO` = 3";
1807     r = run_query(hdb1, 0, query);
1808     ok(r == ERROR_SUCCESS, "failed to delete row\n");
1809
1810     hrec = MsiCreateRecord(2);
1811     r = MsiRecordSetInteger(hrec, 1, 1);
1812     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1813
1814     write_file("testdata.bin", "naengmyon", 9);
1815     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
1816     ok(r == ERROR_SUCCESS, "failed to set stream\n");
1817
1818     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
1819     r = run_query(hdb1, hrec, query);
1820     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
1821
1822     MsiCloseHandle(hrec);
1823
1824     /* database needs to be committed */
1825     MsiDatabaseCommit(hdb1);
1826
1827     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
1828     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1829
1830     MsiCloseHandle( hdb1 );
1831     MsiCloseHandle( hdb2 );
1832
1833     DeleteFile("testdata.bin");
1834 }
1835
1836 /* data for generating a transform */
1837
1838 /* tables transform names - encoded as they would be in an msi database file */
1839 static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
1840 static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
1841 static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
1842 static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
1843 static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
1844 static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
1845 static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
1846 static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
1847
1848 /* data in each table */
1849 static const WCHAR data1[] = { /* AAR */
1850     0x0201, 0x0005, 0x8001,  /* 0x0201 = add row (1), two shorts */
1851     0x0201, 0x0006, 0x8002,
1852 };
1853 static const WCHAR data2[] = { /* _Columns */
1854     0x0401, 0x0002, 0x0000, 0x0003, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
1855     0x0401, 0x0002, 0x0000, 0x0004, 0x8502,
1856 };
1857 static const WCHAR data3[] = { /* _Tables */
1858     0x0101, 0x0002, /* 0x0101 = add row (1), 1 short */
1859 };
1860 static const char data4[] = /* _StringData */
1861     "cAARCARBARvwbmw";  /* all the strings squashed together */
1862 static const WCHAR data5[] = { /* _StringPool */
1863 /*  len, refs */
1864     0,   0,    /* string 0 ''    */
1865     1,   1,    /* string 1 'c'   */
1866     3,   3,    /* string 2 'AAR' */
1867     3,   1,    /* string 3 'CAR' */
1868     3,   1,    /* string 4 'BAR' */
1869     2,   1,    /* string 5 'vw'  */
1870     3,   1,    /* string 6 'bmw' */
1871 };
1872 /* update row, 0x0002 is a bitmask of present column data, keys are excluded */
1873 static const WCHAR data6[] = { /* MOO */
1874     0x0002, 0x8001, 0x0001, /* update row */
1875     0x0000, 0x8002,         /* delete row */
1876 };
1877
1878 static const WCHAR data7[] = { /* BINARY */
1879     0x0201, 0x8001, 0x0001,
1880 };
1881
1882 static const char data8[] =  /* stream data for the BINARY table */
1883     "naengmyon";
1884
1885 static const struct {
1886     LPCWSTR name;
1887     const void *data;
1888     DWORD size;
1889 } table_transform_data[] =
1890 {
1891     { name1, data1, sizeof data1 },
1892     { name2, data2, sizeof data2 },
1893     { name3, data3, sizeof data3 },
1894     { name4, data4, sizeof data4 - 1 },
1895     { name5, data5, sizeof data5 },
1896     { name6, data6, sizeof data6 },
1897     { name7, data7, sizeof data7 },
1898     { name8, data8, sizeof data8 - 1 },
1899 };
1900
1901 #define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
1902
1903 static void generate_transform_manual(void)
1904 {
1905     IStorage *stg = NULL;
1906     IStream *stm;
1907     WCHAR name[0x20];
1908     HRESULT r;
1909     DWORD i, count;
1910     const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
1911
1912     const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
1913
1914     MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
1915
1916     r = StgCreateDocfile(name, mode, 0, &stg);
1917     ok(r == S_OK, "failed to create storage\n");
1918     if (!stg)
1919         return;
1920
1921     r = IStorage_SetClass( stg, &CLSID_MsiTransform );
1922     ok(r == S_OK, "failed to set storage type\n");
1923
1924     for (i=0; i<NUM_TRANSFORM_TABLES; i++)
1925     {
1926         r = IStorage_CreateStream( stg, table_transform_data[i].name,
1927                             STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
1928         if (FAILED(r))
1929         {
1930             ok(0, "failed to create stream %08x\n", r);
1931             continue;
1932         }
1933
1934         r = IStream_Write( stm, table_transform_data[i].data,
1935                           table_transform_data[i].size, &count );
1936         if (FAILED(r) || count != table_transform_data[i].size)
1937             ok(0, "failed to write stream\n");
1938         IStream_Release(stm);
1939     }
1940
1941     IStorage_Release(stg);
1942 }
1943
1944 static void test_try_transform(void)
1945 {
1946     MSIHANDLE hdb, hview, hrec;
1947     LPCSTR query;
1948     UINT r;
1949     DWORD sz;
1950     char buffer[0x10];
1951
1952     DeleteFile(msifile);
1953     DeleteFile(msifile2);
1954     DeleteFile(mstfile);
1955
1956     /* create an empty database */
1957     r = MsiOpenDatabase(msifile2, MSIDBOPEN_CREATE, &hdb );
1958     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1959
1960     query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
1961     r = run_query(hdb, 0, query);
1962     ok(r == ERROR_SUCCESS, "failed to add table\n");
1963
1964     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
1965     r = run_query(hdb, 0, query);
1966     ok(r == ERROR_SUCCESS, "failed to add row\n");
1967
1968     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
1969     r = run_query(hdb, 0, query);
1970     ok(r == ERROR_SUCCESS, "failed to add row\n");
1971
1972     query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
1973     r = run_query(hdb, 0, query);
1974     ok(r == ERROR_SUCCESS, "failed to add row\n");
1975
1976     query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
1977     r = run_query(hdb, 0, query);
1978     ok(r == ERROR_SUCCESS, "failed to add table\n");
1979
1980     hrec = MsiCreateRecord(2);
1981     r = MsiRecordSetInteger(hrec, 1, 2);
1982     ok(r == ERROR_SUCCESS, "failed to set integer\n");
1983
1984     write_file("testdata.bin", "lamyon", 6);
1985     r = MsiRecordSetStream(hrec, 2, "testdata.bin");
1986     ok(r == ERROR_SUCCESS, "failed to set stream\n");
1987
1988     query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
1989     r = run_query(hdb, hrec, query);
1990     ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
1991
1992     MsiCloseHandle(hrec);
1993
1994     r = MsiDatabaseCommit( hdb );
1995     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1996
1997     MsiCloseHandle( hdb );
1998     DeleteFileA("testdata.bin");
1999
2000     /*
2001      * Both these generate an equivilent transform,
2002      *  but the first doesn't work in Wine yet
2003      *  because MsiDatabaseGenerateTransform is unimplemented.
2004      */
2005     if (0)
2006         generate_transform();
2007     else
2008         generate_transform_manual();
2009
2010     r = MsiOpenDatabase(msifile2, MSIDBOPEN_DIRECT, &hdb );
2011     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
2012
2013     r = MsiDatabaseApplyTransform( hdb, mstfile, 0 );
2014     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
2015
2016     MsiDatabaseCommit( hdb );
2017
2018     /* check new values */
2019     hrec = 0;
2020     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
2021     r = do_query(hdb, query, &hrec);
2022     ok(r == ERROR_SUCCESS, "select query failed\n");
2023     MsiCloseHandle(hrec);
2024
2025     query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
2026     hrec = 0;
2027     r = do_query(hdb, query, &hrec);
2028     ok(r == ERROR_SUCCESS, "select query failed\n");
2029     MsiCloseHandle(hrec);
2030
2031     /* check updated values */
2032     hrec = 0;
2033     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
2034     r = do_query(hdb, query, &hrec);
2035     ok(r == ERROR_SUCCESS, "select query failed\n");
2036     MsiCloseHandle(hrec);
2037
2038     /* check unchanged value */
2039     hrec = 0;
2040     query = "select `NOO`,`OOO` from `MOO` where `NOO` = 3 AND `OOO` = 'c'";
2041     r = do_query(hdb, query, &hrec);
2042     ok(r == ERROR_SUCCESS, "select query failed\n");
2043     MsiCloseHandle(hrec);
2044
2045     /* check deleted value */
2046     hrec = 0;
2047     query = "select * from `MOO` where `NOO` = 2";
2048     r = do_query(hdb, query, &hrec);
2049     ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
2050     if (hrec) MsiCloseHandle(hrec);
2051
2052     /* check added stream */
2053     hrec = 0;
2054     query = "select `BLOB` from `BINARY` where `ID` = 1";
2055     r = do_query(hdb, query, &hrec);
2056     ok(r == ERROR_SUCCESS, "select query failed\n");
2057
2058     /* check the contents of the stream */
2059     sz = sizeof buffer;
2060     r = MsiRecordReadStream( hrec, 1, buffer, &sz );
2061     ok(r == ERROR_SUCCESS, "read stream failed\n");
2062     ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
2063     ok(sz == 9, "stream data was wrong size\n");
2064     if (hrec) MsiCloseHandle(hrec);
2065
2066     /* check the validity of the table with a deleted row */
2067     hrec = 0;
2068     query = "select * from `MOO`";
2069     r = MsiDatabaseOpenView(hdb, query, &hview);
2070     ok(r == ERROR_SUCCESS, "open view failed\n");
2071
2072     r = MsiViewExecute(hview, 0);
2073     ok(r == ERROR_SUCCESS, "view execute failed\n");
2074
2075     r = MsiViewFetch(hview, &hrec);
2076     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2077
2078     r = MsiRecordGetInteger(hrec, 1);
2079     ok(r == 1, "Expected 1, got %d\n", r);
2080
2081     sz = sizeof buffer;
2082     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2083     ok(r == ERROR_SUCCESS, "record get string failed\n");
2084     ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
2085
2086     MsiCloseHandle(hrec);
2087
2088     r = MsiViewFetch(hview, &hrec);
2089     ok(r == ERROR_SUCCESS, "view fetch failed\n");
2090
2091     r = MsiRecordGetInteger(hrec, 1);
2092     ok(r == 3, "Expected 3, got %d\n", r);
2093
2094     sz = sizeof buffer;
2095     r = MsiRecordGetString(hrec, 2, buffer, &sz);
2096     ok(r == ERROR_SUCCESS, "record get string failed\n");
2097     ok(!lstrcmpA(buffer, "c"), "Expected b, got %s\n", buffer);
2098
2099     MsiCloseHandle(hrec);
2100
2101     r = MsiViewFetch(hview, &hrec);
2102     ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
2103
2104     MsiCloseHandle(hrec);
2105     MsiCloseHandle(hview);
2106     MsiCloseHandle(hdb);
2107
2108     DeleteFile(msifile);
2109     DeleteFile(msifile2);
2110     DeleteFile(mstfile);
2111 }
2112
2113 struct join_res
2114 {
2115     const CHAR one[MAX_PATH];
2116     const CHAR two[MAX_PATH];
2117 };
2118
2119 struct join_res_4col
2120 {
2121     const CHAR one[MAX_PATH];
2122     const CHAR two[MAX_PATH];
2123     const CHAR three[MAX_PATH];
2124     const CHAR four[MAX_PATH];
2125 };
2126
2127 static const struct join_res join_res_first[] =
2128 {
2129     { "alveolar", "procerus" },
2130     { "septum", "procerus" },
2131     { "septum", "nasalis" },
2132     { "ramus", "nasalis" },
2133     { "malar", "mentalis" },
2134 };
2135
2136 static const struct join_res join_res_second[] =
2137 {
2138     { "nasal", "septum" },
2139     { "mandible", "ramus" },
2140 };
2141
2142 static const struct join_res join_res_third[] =
2143 {
2144     { "msvcp.dll", "abcdefgh" },
2145     { "msvcr.dll", "ijklmnop" },
2146 };
2147
2148 static const struct join_res join_res_fourth[] =
2149 {
2150     { "msvcp.dll.01234", "single.dll.31415" },
2151 };
2152
2153 static const struct join_res join_res_fifth[] =
2154 {
2155     { "malar", "procerus" },
2156 };
2157
2158 static const struct join_res join_res_sixth[] =
2159 {
2160     { "malar", "procerus" },
2161     { "malar", "procerus" },
2162     { "malar", "nasalis" },
2163     { "malar", "nasalis" },
2164     { "malar", "nasalis" },
2165     { "malar", "mentalis" },
2166 };
2167
2168 static const struct join_res join_res_seventh[] =
2169 {
2170     { "malar", "nasalis" },
2171     { "malar", "nasalis" },
2172     { "malar", "nasalis" },
2173 };
2174
2175 static const struct join_res_4col join_res_eighth[] =
2176 {
2177     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
2178     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
2179     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
2180     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
2181     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
2182     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
2183 };
2184
2185 static void test_join(void)
2186 {
2187     MSIHANDLE hdb, hview, hrec;
2188     LPCSTR query;
2189     CHAR buf[MAX_PATH];
2190     UINT r, count;
2191     DWORD size, i;
2192     BOOL data_correct;
2193
2194     hdb = create_db();
2195     ok( hdb, "failed to create db\n");
2196
2197     r = create_component_table( hdb );
2198     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
2199
2200     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
2201     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2202
2203     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
2204     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2205
2206     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
2207     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2208
2209     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
2210     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
2211
2212     r = create_feature_components_table( hdb );
2213     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
2214
2215     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
2216     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2217
2218     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
2219     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2220
2221     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
2222     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2223
2224     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
2225     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2226
2227     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
2228     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2229
2230     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
2231     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
2232
2233     r = create_std_dlls_table( hdb );
2234     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
2235
2236     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
2237     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2238
2239     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
2240     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
2241
2242     r = create_binary_table( hdb );
2243     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
2244
2245     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
2246     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2247
2248     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
2249     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2250
2251     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
2252     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
2253
2254     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2255             "FROM `Component`, `FeatureComponents` "
2256             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
2257             "ORDER BY `Feature_`";
2258     r = MsiDatabaseOpenView(hdb, query, &hview);
2259     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2260
2261     r = MsiViewExecute(hview, 0);
2262     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2263
2264     i = 0;
2265     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2266     {
2267         count = MsiRecordGetFieldCount( hrec );
2268         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2269
2270         size = MAX_PATH;
2271         r = MsiRecordGetString( hrec, 1, buf, &size );
2272         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2273         ok( !lstrcmp( buf, join_res_first[i].one ),
2274             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
2275
2276         size = MAX_PATH;
2277         r = MsiRecordGetString( hrec, 2, buf, &size );
2278         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2279         ok( !lstrcmp( buf, join_res_first[i].two ),
2280             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
2281
2282         i++;
2283         MsiCloseHandle(hrec);
2284     }
2285
2286     ok( i == 5, "Expected 5 rows, got %d\n", i );
2287     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2288
2289     MsiViewClose(hview);
2290     MsiCloseHandle(hview);
2291
2292     /* try a join without a WHERE condition */
2293     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2294             "FROM `Component`, `FeatureComponents` ";
2295     r = MsiDatabaseOpenView(hdb, query, &hview);
2296     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2297
2298     r = MsiViewExecute(hview, 0);
2299     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2300
2301     i = 0;
2302     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2303     {
2304         i++;
2305         MsiCloseHandle(hrec);
2306     }
2307     ok( i == 24, "Expected 24 rows, got %d\n", i );
2308
2309     MsiViewClose(hview);
2310     MsiCloseHandle(hview);
2311
2312     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
2313             "WHERE FeatureComponents.Component_=Component.Component "
2314             "AND (Feature_='nasalis') ORDER BY Feature_";
2315     r = MsiDatabaseOpenView(hdb, query, &hview);
2316     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2317
2318     r = MsiViewExecute(hview, 0);
2319     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2320
2321     i = 0;
2322     data_correct = TRUE;
2323     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2324     {
2325         count = MsiRecordGetFieldCount( hrec );
2326         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2327
2328         size = MAX_PATH;
2329         r = MsiRecordGetString( hrec, 1, buf, &size );
2330         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2331         if( lstrcmp( buf, join_res_second[i].one ))
2332             data_correct = FALSE;
2333
2334         size = MAX_PATH;
2335         r = MsiRecordGetString( hrec, 2, buf, &size );
2336         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2337         if( lstrcmp( buf, join_res_second[i].two ))
2338             data_correct = FALSE;
2339
2340         i++;
2341         MsiCloseHandle(hrec);
2342     }
2343
2344     ok( data_correct, "data returned in the wrong order\n");
2345
2346     ok( i == 2, "Expected 2 rows, got %d\n", i );
2347     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2348
2349     MsiViewClose(hview);
2350     MsiCloseHandle(hview);
2351
2352     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2353             "FROM `StdDlls`, `Binary` "
2354             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
2355             "ORDER BY `File`";
2356     r = MsiDatabaseOpenView(hdb, query, &hview);
2357     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2358
2359     r = MsiViewExecute(hview, 0);
2360     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2361
2362     i = 0;
2363     data_correct = TRUE;
2364     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2365     {
2366         count = MsiRecordGetFieldCount( hrec );
2367         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2368
2369         size = MAX_PATH;
2370         r = MsiRecordGetString( hrec, 1, buf, &size );
2371         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2372         if( lstrcmp( buf, join_res_third[i].one ) )
2373             data_correct = FALSE;
2374
2375         size = MAX_PATH;
2376         r = MsiRecordGetString( hrec, 2, buf, &size );
2377         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2378         if( lstrcmp( buf, join_res_third[i].two ) )
2379             data_correct = FALSE;
2380
2381         i++;
2382         MsiCloseHandle(hrec);
2383     }
2384     ok( data_correct, "data returned in the wrong order\n");
2385
2386     ok( i == 2, "Expected 2 rows, got %d\n", i );
2387
2388     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2389
2390     MsiViewClose(hview);
2391     MsiCloseHandle(hview);
2392
2393     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
2394             "FROM `StdDlls`, `Binary` "
2395             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
2396             "ORDER BY `Name`";
2397     r = MsiDatabaseOpenView(hdb, query, &hview);
2398     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2399
2400     r = MsiViewExecute(hview, 0);
2401     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2402
2403     i = 0;
2404     data_correct = TRUE;
2405     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2406     {
2407         count = MsiRecordGetFieldCount( hrec );
2408         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2409
2410         size = MAX_PATH;
2411         r = MsiRecordGetString( hrec, 1, buf, &size );
2412         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2413         if( lstrcmp( buf, join_res_fourth[i].one ))
2414             data_correct = FALSE;
2415
2416         size = MAX_PATH;
2417         r = MsiRecordGetString( hrec, 2, buf, &size );
2418         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2419         if( lstrcmp( buf, join_res_fourth[i].two ))
2420             data_correct = FALSE;
2421
2422         i++;
2423         MsiCloseHandle(hrec);
2424     }
2425     ok( data_correct, "data returned in the wrong order\n");
2426
2427     ok( i == 1, "Expected 1 rows, got %d\n", i );
2428     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2429
2430     MsiViewClose(hview);
2431     MsiCloseHandle(hview);
2432
2433     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2434             "FROM `Component`, `FeatureComponents` "
2435             "WHERE `Component`.`Component` = 'zygomatic' "
2436             "AND `FeatureComponents`.`Component_` = 'maxilla' "
2437             "ORDER BY `Feature_`";
2438     r = MsiDatabaseOpenView(hdb, query, &hview);
2439     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2440
2441     r = MsiViewExecute(hview, 0);
2442     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2443
2444     i = 0;
2445     data_correct = TRUE;
2446     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2447     {
2448         count = MsiRecordGetFieldCount( hrec );
2449         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2450
2451         size = MAX_PATH;
2452         r = MsiRecordGetString( hrec, 1, buf, &size );
2453         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2454         if( lstrcmp( buf, join_res_fifth[i].one ))
2455             data_correct = FALSE;
2456
2457         size = MAX_PATH;
2458         r = MsiRecordGetString( hrec, 2, buf, &size );
2459         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2460         if( lstrcmp( buf, join_res_fifth[i].two ))
2461             data_correct = FALSE;
2462
2463         i++;
2464         MsiCloseHandle(hrec);
2465     }
2466     ok( data_correct, "data returned in the wrong order\n");
2467
2468     ok( i == 1, "Expected 1 rows, got %d\n", i );
2469     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2470
2471     MsiViewClose(hview);
2472     MsiCloseHandle(hview);
2473
2474     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2475             "FROM `Component`, `FeatureComponents` "
2476             "WHERE `Component` = 'zygomatic' "
2477             "ORDER BY `Feature_`";
2478     r = MsiDatabaseOpenView(hdb, query, &hview);
2479     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2480
2481     r = MsiViewExecute(hview, 0);
2482     todo_wine
2483     {
2484         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2485     }
2486
2487     i = 0;
2488     data_correct = TRUE;
2489     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2490     {
2491         count = MsiRecordGetFieldCount( hrec );
2492         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2493
2494         size = MAX_PATH;
2495         r = MsiRecordGetString( hrec, 1, buf, &size );
2496         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2497         if( lstrcmp( buf, join_res_sixth[i].one ))
2498             data_correct = FALSE;
2499
2500         size = MAX_PATH;
2501         r = MsiRecordGetString( hrec, 2, buf, &size );
2502         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2503         if( lstrcmp( buf, join_res_sixth[i].two ))
2504             data_correct = FALSE;
2505
2506         i++;
2507         MsiCloseHandle(hrec);
2508     }
2509     ok( data_correct, "data returned in the wrong order\n");
2510
2511     todo_wine
2512     {
2513         ok( i == 6, "Expected 6 rows, got %d\n", i );
2514     }
2515     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2516
2517     MsiViewClose(hview);
2518     MsiCloseHandle(hview);
2519
2520     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2521             "FROM `Component`, `FeatureComponents` "
2522             "WHERE `Component` = 'zygomatic' "
2523             "AND `Feature_` = 'nasalis' "
2524             "ORDER BY `Feature_`";
2525     r = MsiDatabaseOpenView(hdb, query, &hview);
2526     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2527
2528     r = MsiViewExecute(hview, 0);
2529     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2530
2531     i = 0;
2532     data_correct = TRUE;
2533     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2534     {
2535         count = MsiRecordGetFieldCount( hrec );
2536         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2537
2538         size = MAX_PATH;
2539         r = MsiRecordGetString( hrec, 1, buf, &size );
2540         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2541         if( lstrcmp( buf, join_res_seventh[i].one ))
2542             data_correct = FALSE;
2543
2544         size = MAX_PATH;
2545         r = MsiRecordGetString( hrec, 2, buf, &size );
2546         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2547         if( lstrcmp( buf, join_res_seventh[i].two ))
2548             data_correct = FALSE;
2549
2550         i++;
2551         MsiCloseHandle(hrec);
2552     }
2553
2554     ok( data_correct, "data returned in the wrong order\n");
2555     ok( i == 3, "Expected 3 rows, got %d\n", i );
2556     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2557
2558     MsiViewClose(hview);
2559     MsiCloseHandle(hview);
2560
2561     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2562             "FROM `StdDlls`, `Binary` ";
2563     r = MsiDatabaseOpenView(hdb, query, &hview);
2564     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2565
2566     r = MsiViewExecute(hview, 0);
2567     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2568
2569     i = 0;
2570     data_correct = TRUE;
2571     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2572     {
2573         count = MsiRecordGetFieldCount( hrec );
2574         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2575
2576         size = MAX_PATH;
2577         r = MsiRecordGetString( hrec, 1, buf, &size );
2578         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2579         if( lstrcmp( buf, join_res_eighth[i].one ))
2580             data_correct = FALSE;
2581
2582         size = MAX_PATH;
2583         r = MsiRecordGetString( hrec, 2, buf, &size );
2584         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2585         if( lstrcmp( buf, join_res_eighth[i].four ))
2586             data_correct = FALSE;
2587
2588         i++;
2589         MsiCloseHandle(hrec);
2590     }
2591
2592     todo_wine ok( data_correct, "data returned in the wrong order\n");
2593     ok( i == 6, "Expected 6 rows, got %d\n", i );
2594     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2595
2596     MsiViewClose(hview);
2597     MsiCloseHandle(hview);
2598
2599     query = "SELECT * FROM `StdDlls`, `Binary` ";
2600     r = MsiDatabaseOpenView(hdb, query, &hview);
2601     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2602
2603     r = MsiViewExecute(hview, 0);
2604     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2605
2606     i = 0;
2607     data_correct = TRUE;
2608     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2609     {
2610         count = MsiRecordGetFieldCount( hrec );
2611         ok( count == 4, "Expected 4 record fields, got %d\n", count );
2612
2613         size = MAX_PATH;
2614         r = MsiRecordGetString( hrec, 1, buf, &size );
2615         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2616         if( lstrcmp( buf, join_res_eighth[i].one ))
2617             data_correct = FALSE;
2618
2619         size = MAX_PATH;
2620         r = MsiRecordGetString( hrec, 2, buf, &size );
2621         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2622         if( lstrcmp( buf, join_res_eighth[i].two ))
2623             data_correct = FALSE;
2624
2625         size = MAX_PATH;
2626         r = MsiRecordGetString( hrec, 3, buf, &size );
2627         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2628         if( lstrcmp( buf, join_res_eighth[i].three ))
2629             data_correct = FALSE;
2630
2631         size = MAX_PATH;
2632         r = MsiRecordGetString( hrec, 4, buf, &size );
2633         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2634         if( lstrcmp( buf, join_res_eighth[i].four ))
2635             data_correct = FALSE;
2636
2637         i++;
2638         MsiCloseHandle(hrec);
2639     }
2640     todo_wine ok( data_correct, "data returned in the wrong order\n");
2641
2642     ok( i == 6, "Expected 6 rows, got %d\n", i );
2643     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2644
2645     MsiViewClose(hview);
2646     MsiCloseHandle(hview);
2647
2648     MsiCloseHandle(hdb);
2649     DeleteFile(msifile);
2650 }
2651
2652 static void test_temporary_table(void)
2653 {
2654     MSICONDITION cond;
2655     MSIHANDLE hdb = 0, view = 0, rec;
2656     const char *query;
2657     UINT r;
2658     char buf[0x10];
2659     DWORD sz;
2660
2661     cond = MsiDatabaseIsTablePersistent(0, NULL);
2662     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2663
2664     hdb = create_db();
2665     ok( hdb, "failed to create db\n");
2666
2667     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
2668     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2669
2670     todo_wine {
2671     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
2672     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2673
2674     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
2675     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2676     }
2677
2678     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
2679     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2680
2681     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
2682     r = run_query(hdb, 0, query);
2683     ok(r == ERROR_SUCCESS, "failed to add table\n");
2684
2685     cond = MsiDatabaseIsTablePersistent(hdb, "P");
2686     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2687
2688     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
2689     r = run_query(hdb, 0, query);
2690     ok(r == ERROR_SUCCESS, "failed to add table\n");
2691
2692     cond = MsiDatabaseIsTablePersistent(hdb, "P2");
2693     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2694
2695     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
2696     r = run_query(hdb, 0, query);
2697     ok(r == ERROR_SUCCESS, "failed to add table\n");
2698
2699     cond = MsiDatabaseIsTablePersistent(hdb, "T");
2700     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
2701
2702     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2703     r = run_query(hdb, 0, query);
2704     ok(r == ERROR_SUCCESS, "failed to add table\n");
2705
2706     todo_wine {
2707     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
2708     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2709     }
2710
2711     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
2712     r = run_query(hdb, 0, query);
2713     ok(r == ERROR_SUCCESS, "failed to add table\n");
2714
2715     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
2716     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2717
2718     todo_wine {
2719     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2720     r = run_query(hdb, 0, query);
2721     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
2722
2723     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
2724     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2725     }
2726
2727     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
2728     r = run_query(hdb, 0, query);
2729     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
2730
2731     query = "select * from `T`";
2732     r = MsiDatabaseOpenView(hdb, query, &view);
2733     ok(r == ERROR_SUCCESS, "failed to query table\n");
2734     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2735     ok(r == ERROR_SUCCESS, "failed to get column info\n");
2736
2737     sz = sizeof buf;
2738     r = MsiRecordGetString(rec, 1, buf, &sz);
2739     ok(r == ERROR_SUCCESS, "failed to get string\n");
2740     todo_wine ok( 0 == strcmp("G255", buf), "wrong column type\n");
2741
2742     sz = sizeof buf;
2743     r = MsiRecordGetString(rec, 2, buf, &sz);
2744     ok(r == ERROR_SUCCESS, "failed to get string\n");
2745     todo_wine ok( 0 == strcmp("j2", buf), "wrong column type\n");
2746
2747     MsiCloseHandle( rec );
2748     MsiCloseHandle( view );
2749
2750     /* query the table data */
2751     rec = 0;
2752     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
2753     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
2754     MsiCloseHandle( rec );
2755
2756     /* query the column data */
2757     rec = 0;
2758     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
2759     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2760     if (rec) MsiCloseHandle( rec );
2761
2762     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
2763     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2764     if (rec) MsiCloseHandle( rec );
2765
2766     MsiCloseHandle( hdb );
2767
2768     DeleteFile(msifile);
2769 }
2770
2771 static void test_alter(void)
2772 {
2773     MSICONDITION cond;
2774     MSIHANDLE hdb = 0;
2775     const char *query;
2776     UINT r;
2777
2778     hdb = create_db();
2779     ok( hdb, "failed to create db\n");
2780
2781     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
2782     r = run_query(hdb, 0, query);
2783     ok(r == ERROR_SUCCESS, "failed to add table\n");
2784
2785     cond = MsiDatabaseIsTablePersistent(hdb, "T");
2786     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
2787
2788     query = "ALTER TABLE `T` HOLD";
2789     r = run_query(hdb, 0, query);
2790     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
2791
2792     query = "ALTER TABLE `T` FREE";
2793     r = run_query(hdb, 0, query);
2794     ok(r == ERROR_SUCCESS, "failed to free table\n");
2795
2796     query = "ALTER TABLE `T` FREE";
2797     r = run_query(hdb, 0, query);
2798     ok(r == ERROR_SUCCESS, "failed to free table\n");
2799
2800     todo_wine {
2801     query = "ALTER TABLE `T` FREE";
2802     r = run_query(hdb, 0, query);
2803     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
2804
2805     query = "ALTER TABLE `T` HOLD";
2806     r = run_query(hdb, 0, query);
2807     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
2808     }
2809
2810     MsiCloseHandle( hdb );
2811
2812     DeleteFile(msifile);
2813 }
2814
2815 static void test_integers(void)
2816 {
2817     MSIHANDLE hdb = 0, view = 0, rec = 0;
2818     DWORD count, i;
2819     const char *query;
2820     UINT r;
2821
2822     /* just MsiOpenDatabase should not create a file */
2823     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
2824     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
2825
2826     /* create a table */
2827     query = "CREATE TABLE `integers` ( "
2828             "`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
2829             "`five` SHORT NOT NULL, `six` INT NOT NULL, "
2830             "`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
2831             "PRIMARY KEY `one`)";
2832     r = MsiDatabaseOpenView(hdb, query, &view);
2833     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
2834     r = MsiViewExecute(view, 0);
2835     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
2836     r = MsiViewClose(view);
2837     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
2838     r = MsiCloseHandle(view);
2839     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
2840
2841     query = "SELECT * FROM `integers`";
2842     r = MsiDatabaseOpenView(hdb, query, &view);
2843     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2844
2845     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
2846     count = MsiRecordGetFieldCount(rec);
2847     ok(count == 8, "Expected 8, got %d\n", count);
2848     ok(check_record(rec, 1, "one"), "Expected one\n");
2849     ok(check_record(rec, 2, "two"), "Expected two\n");
2850     ok(check_record(rec, 3, "three"), "Expected three\n");
2851     ok(check_record(rec, 4, "four"), "Expected four\n");
2852     ok(check_record(rec, 5, "five"), "Expected five\n");
2853     ok(check_record(rec, 6, "six"), "Expected six\n");
2854     ok(check_record(rec, 7, "seven"), "Expected seven\n");
2855     ok(check_record(rec, 8, "eight"), "Expected eight\n");
2856     MsiCloseHandle(rec);
2857
2858     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2859     count = MsiRecordGetFieldCount(rec);
2860     ok(count == 8, "Expected 8, got %d\n", count);
2861     ok(check_record(rec, 1, "I2"), "Expected I2\n");
2862     ok(check_record(rec, 2, "I2"), "Expected I2\n");
2863     ok(check_record(rec, 3, "I2"), "Expected I2\n");
2864     ok(check_record(rec, 4, "I4"), "Expected I4\n");
2865     ok(check_record(rec, 5, "i2"), "Expected i2\n");
2866     ok(check_record(rec, 6, "i2"), "Expected i2\n");
2867     ok(check_record(rec, 7, "i2"), "Expected i2\n");
2868     ok(check_record(rec, 8, "i4"), "Expected i4\n");
2869     MsiCloseHandle(rec);
2870
2871     MsiViewClose(view);
2872     MsiCloseHandle(view);
2873
2874     /* insert values into it, NULL where NOT NULL is specified */
2875     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
2876         "VALUES('', '', '', '', '', '', '', '')";
2877     r = MsiDatabaseOpenView(hdb, query, &view);
2878     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2879     r = MsiViewExecute(view, 0);
2880     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
2881
2882     MsiViewClose(view);
2883     MsiCloseHandle(view);
2884
2885     query = "SELECT * FROM `integers`";
2886     r = do_query(hdb, query, &rec);
2887     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
2888
2889     r = MsiRecordGetFieldCount(rec);
2890     ok(r == -1, "record count wrong: %d\n", r);
2891
2892     MsiCloseHandle(rec);
2893
2894     /* insert legitimate values into it */
2895     query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
2896         "VALUES('', '2', '', '4', '5', '6', '7', '8')";
2897     r = MsiDatabaseOpenView(hdb, query, &view);
2898     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2899     r = MsiViewExecute(view, 0);
2900     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2901
2902     query = "SELECT * FROM `integers`";
2903     r = do_query(hdb, query, &rec);
2904     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2905
2906     r = MsiRecordGetFieldCount(rec);
2907     ok(r == 8, "record count wrong: %d\n", r);
2908
2909     i = MsiRecordGetInteger(rec, 1);
2910     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2911     i = MsiRecordGetInteger(rec, 3);
2912     ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
2913     i = MsiRecordGetInteger(rec, 2);
2914     ok(i == 2, "Expected 2, got %d\n", i);
2915     i = MsiRecordGetInteger(rec, 4);
2916     ok(i == 4, "Expected 4, got %d\n", i);
2917     i = MsiRecordGetInteger(rec, 5);
2918     ok(i == 5, "Expected 5, got %d\n", i);
2919     i = MsiRecordGetInteger(rec, 6);
2920     ok(i == 6, "Expected 6, got %d\n", i);
2921     i = MsiRecordGetInteger(rec, 7);
2922     ok(i == 7, "Expected 7, got %d\n", i);
2923     i = MsiRecordGetInteger(rec, 8);
2924     ok(i == 8, "Expected 8, got %d\n", i);
2925
2926     MsiCloseHandle(rec);
2927     MsiViewClose(view);
2928     MsiCloseHandle(view);
2929
2930     r = MsiDatabaseCommit(hdb);
2931     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
2932
2933     r = MsiCloseHandle(hdb);
2934     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
2935
2936     r = DeleteFile(msifile);
2937     ok(r == TRUE, "file didn't exist after commit\n");
2938 }
2939
2940 static void test_update(void)
2941 {
2942     MSIHANDLE hdb = 0, view = 0, rec = 0;
2943     CHAR result[MAX_PATH];
2944     const char *query;
2945     DWORD size;
2946     UINT r;
2947
2948     /* just MsiOpenDatabase should not create a file */
2949     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
2950     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
2951
2952     /* create the Control table */
2953     query = "CREATE TABLE `Control` ( "
2954         "`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
2955         "`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
2956         "`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
2957         "`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
2958     r = MsiDatabaseOpenView(hdb, query, &view);
2959     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
2960     r = MsiViewExecute(view, 0);
2961     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
2962     r = MsiViewClose(view);
2963     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
2964     r = MsiCloseHandle(view);
2965     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
2966
2967     /* add a control */
2968     query = "INSERT INTO `Control` ( "
2969         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
2970         "`Property`, `Text`, `Control_Next`, `Help` )"
2971         "VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
2972     r = MsiDatabaseOpenView(hdb, query, &view);
2973     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2974     r = MsiViewExecute(view, 0);
2975     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2976     r = MsiViewClose(view);
2977     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
2978     r = MsiCloseHandle(view);
2979     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
2980
2981     /* add a second control */
2982     query = "INSERT INTO `Control` ( "
2983         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
2984         "`Property`, `Text`, `Control_Next`, `Help` )"
2985         "VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
2986     r = MsiDatabaseOpenView(hdb, query, &view);
2987     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2988     r = MsiViewExecute(view, 0);
2989     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
2990     r = MsiViewClose(view);
2991     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
2992     r = MsiCloseHandle(view);
2993     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
2994
2995     /* add a third control */
2996     query = "INSERT INTO `Control` ( "
2997         "`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
2998         "`Property`, `Text`, `Control_Next`, `Help` )"
2999         "VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
3000     r = MsiDatabaseOpenView(hdb, query, &view);
3001     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3002     r = MsiViewExecute(view, 0);
3003     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3004     r = MsiViewClose(view);
3005     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3006     r = MsiCloseHandle(view);
3007     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3008
3009     /* bad table */
3010     query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3011     r = MsiDatabaseOpenView(hdb, query, &view);
3012     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3013
3014     /* bad set column */
3015     query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3016     r = MsiDatabaseOpenView(hdb, query, &view);
3017     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3018
3019     /* bad where condition */
3020     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
3021     r = MsiDatabaseOpenView(hdb, query, &view);
3022     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
3023
3024     /* just the dialog_ specified */
3025     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
3026     r = MsiDatabaseOpenView(hdb, query, &view);
3027     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3028     r = MsiViewExecute(view, 0);
3029     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3030     r = MsiViewClose(view);
3031     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3032     r = MsiCloseHandle(view);
3033     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3034
3035     /* check the modified text */
3036     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3037     r = MsiDatabaseOpenView(hdb, query, &view);
3038     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3039     r = MsiViewExecute(view, 0);
3040     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3041
3042     r = MsiViewFetch(view, &rec);
3043     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3044
3045     size = MAX_PATH;
3046     r = MsiRecordGetString(rec, 1, result, &size);
3047     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3048     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3049
3050     MsiCloseHandle(rec);
3051
3052     r = MsiViewFetch(view, &rec);
3053     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3054
3055     size = MAX_PATH;
3056     r = MsiRecordGetString(rec, 1, result, &size);
3057     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3058     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3059
3060     MsiCloseHandle(rec);
3061
3062     r = MsiViewFetch(view, &rec);
3063     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3064
3065     r = MsiViewClose(view);
3066     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3067     r = MsiCloseHandle(view);
3068     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3069
3070     /* dialog_ and control specified */
3071     query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
3072     r = MsiDatabaseOpenView(hdb, query, &view);
3073     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3074     r = MsiViewExecute(view, 0);
3075     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3076     r = MsiViewClose(view);
3077     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3078     r = MsiCloseHandle(view);
3079     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3080
3081     /* check the modified text */
3082     query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
3083     r = MsiDatabaseOpenView(hdb, query, &view);
3084     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3085     r = MsiViewExecute(view, 0);
3086     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3087
3088     r = MsiViewFetch(view, &rec);
3089     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3090
3091     size = MAX_PATH;
3092     r = MsiRecordGetString(rec, 1, result, &size);
3093     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3094     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3095
3096     MsiCloseHandle(rec);
3097
3098     r = MsiViewFetch(view, &rec);
3099     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3100
3101     size = MAX_PATH;
3102     r = MsiRecordGetString(rec, 1, result, &size);
3103     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3104     ok(!lstrlen(result), "Expected an empty string, got %s\n", result);
3105
3106     MsiCloseHandle(rec);
3107
3108     r = MsiViewFetch(view, &rec);
3109     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3110
3111     r = MsiViewClose(view);
3112     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3113     r = MsiCloseHandle(view);
3114     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3115
3116     /* no where condition */
3117     query = "UPDATE `Control` SET `Text` = 'this is text'";
3118     r = MsiDatabaseOpenView(hdb, query, &view);
3119     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3120     r = MsiViewExecute(view, 0);
3121     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3122     r = MsiViewClose(view);
3123     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3124     r = MsiCloseHandle(view);
3125     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3126
3127     /* check the modified text */
3128     query = "SELECT `Text` FROM `Control`";
3129     r = MsiDatabaseOpenView(hdb, query, &view);
3130     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3131     r = MsiViewExecute(view, 0);
3132     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3133
3134     r = MsiViewFetch(view, &rec);
3135     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3136
3137     size = MAX_PATH;
3138     r = MsiRecordGetString(rec, 1, result, &size);
3139     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3140     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3141
3142     MsiCloseHandle(rec);
3143
3144     r = MsiViewFetch(view, &rec);
3145     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3146
3147     size = MAX_PATH;
3148     r = MsiRecordGetString(rec, 1, result, &size);
3149     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3150     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3151
3152     MsiCloseHandle(rec);
3153
3154     r = MsiViewFetch(view, &rec);
3155     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3156
3157     size = MAX_PATH;
3158     r = MsiRecordGetString(rec, 1, result, &size);
3159     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3160     ok(!lstrcmp(result, "this is text"), "Expected `this is text`, got %s\n", result);
3161
3162     MsiCloseHandle(rec);
3163
3164     r = MsiViewFetch(view, &rec);
3165     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3166
3167     r = MsiViewClose(view);
3168     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3169     r = MsiCloseHandle(view);
3170     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3171     r = MsiDatabaseCommit(hdb);
3172     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
3173     r = MsiCloseHandle(hdb);
3174     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3175 }
3176
3177 static void test_special_tables(void)
3178 {
3179     const char *query;
3180     MSIHANDLE hdb = 0;
3181     UINT r;
3182
3183     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
3184     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
3185
3186     query = "CREATE TABLE `_Properties` ( "
3187         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3188     r = run_query(hdb, 0, query);
3189     ok(r == ERROR_SUCCESS, "failed to create table\n");
3190
3191     query = "CREATE TABLE `_Streams` ( "
3192         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3193     r = run_query(hdb, 0, query);
3194     todo_wine ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
3195
3196     query = "CREATE TABLE `_Tables` ( "
3197         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3198     r = run_query(hdb, 0, query);
3199     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
3200
3201     query = "CREATE TABLE `_Columns` ( "
3202         "`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
3203     r = run_query(hdb, 0, query);
3204     ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
3205
3206     r = MsiCloseHandle(hdb);
3207     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3208 }
3209
3210 static void test_select_markers(void)
3211 {
3212     MSIHANDLE hdb = 0, rec, view, res;
3213     LPCSTR query;
3214     UINT r;
3215     DWORD size;
3216     CHAR buf[MAX_PATH];
3217
3218     hdb = create_db();
3219     ok( hdb, "failed to create db\n");
3220
3221     r = run_query(hdb, 0,
3222             "CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
3223     ok(r == S_OK, "cannot create table: %d\n", r);
3224
3225     r = run_query(hdb, 0, "INSERT INTO `Table` "
3226             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
3227     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3228
3229     r = run_query(hdb, 0, "INSERT INTO `Table` "
3230             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
3231     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3232
3233     r = run_query(hdb, 0, "INSERT INTO `Table` "
3234             "( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
3235     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3236
3237     r = run_query(hdb, 0, "INSERT INTO `Table` "
3238             "( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
3239     ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
3240
3241     rec = MsiCreateRecord(2);
3242     MsiRecordSetString(rec, 1, "apple");
3243     MsiRecordSetString(rec, 2, "two");
3244
3245     query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
3246     r = MsiDatabaseOpenView(hdb, query, &view);
3247     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3248
3249     r = MsiViewExecute(view, rec);
3250     todo_wine
3251     {
3252         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3253     }
3254
3255     r = MsiViewFetch(view, &res);
3256     todo_wine
3257     {
3258         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3259     }
3260
3261     size = MAX_PATH;
3262     r = MsiRecordGetString(res, 1, buf, &size);
3263     todo_wine
3264     {
3265         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3266         ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
3267     }
3268
3269     size = MAX_PATH;
3270     r = MsiRecordGetString(res, 2, buf, &size);
3271     todo_wine
3272     {
3273         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3274         ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
3275     }
3276
3277     r = MsiRecordGetInteger(res, 3);
3278     todo_wine
3279     {
3280         ok(r == 1, "Expected 1, got %d\n", r);
3281     }
3282
3283     MsiCloseHandle(res);
3284
3285     r = MsiViewFetch(view, &res);
3286     todo_wine
3287     {
3288         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3289     }
3290
3291     size = MAX_PATH;
3292     r = MsiRecordGetString(res, 1, buf, &size);
3293     todo_wine
3294     {
3295         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3296         ok(!lstrcmp(buf, "apple"), "Expected apple, got %s\n", buf);
3297     }
3298
3299     size = MAX_PATH;
3300     r = MsiRecordGetString(res, 2, buf, &size);
3301     todo_wine
3302     {
3303         ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
3304         ok(!lstrcmp(buf, "two"), "Expected two, got %s\n", buf);
3305     }
3306
3307     r = MsiRecordGetInteger(res, 3);
3308     todo_wine
3309     {
3310         ok(r == 2, "Expected 2, got %d\n", r);
3311     }
3312
3313     MsiCloseHandle(res);
3314
3315     r = MsiViewFetch(view, &res);
3316     ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
3317
3318     r = MsiViewClose(view);
3319     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
3320     r = MsiCloseHandle(view);
3321     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3322     r = MsiCloseHandle(hdb);
3323     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
3324 }
3325
3326 START_TEST(db)
3327 {
3328     test_msidatabase();
3329     test_msiinsert();
3330     test_msidecomposedesc();
3331     test_msibadqueries();
3332     test_viewmodify();
3333     test_viewgetcolumninfo();
3334     test_getcolinfo();
3335     test_msiexport();
3336     test_longstrings();
3337     test_streamtable();
3338     test_where();
3339     test_msiimport();
3340     test_markers();
3341     test_handle_limit();
3342     test_try_transform();
3343     test_join();
3344     test_temporary_table();
3345     test_alter();
3346     test_integers();
3347     test_update();
3348     test_special_tables();
3349     test_select_markers();
3350 }