git.oblomov.eu Git - wine/blob - dlls/msi/tests/db.c

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