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