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 #include <stdio.h>
  21
  22 #include <windows.h>
  23 #include <msi.h>
  24 #include <msiquery.h>
  25
  26 #include "wine/test.h"
  27
  28 static const char *msifile = "winetest.msi";
  29 static const char *msifile2 = "winetst2.msi";
  30 static const char *mstfile = "winetst.mst";
  31
  32 #ifndef ERROR_INSTALL_TRANSFORM_FAILURE
  33 #define ERROR_INSTALL_TRANSFORM_FAILURE 1624
  34 #endif
  35
  36 static void test_msidatabase(void)
  37 {
  38     MSIHANDLE hdb = 0, hdb2 = 0;
  39     UINT res;
  40
  41     DeleteFile(msifile);
  42
  43     res = MsiOpenDatabase( msifile, msifile2, &hdb );
  44     ok( res == ERROR_OPEN_FAILED, "expected failure\n");
  45
  46     res = MsiOpenDatabase( msifile, (LPSTR) 0xff, &hdb );
  47     ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
  48
  49     res = MsiCloseHandle( hdb );
  50     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  51
  52     /* create an empty database */
  53     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
  54     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
  55
  56     res = MsiDatabaseCommit( hdb );
  57     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  58
  59     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
  60
  61     res = MsiCloseHandle( hdb );
  62     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  63     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  64     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  65
  66     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "database should exist\n");
  67
  68     res = MsiDatabaseCommit( hdb2 );
  69     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  70
  71     res = MsiCloseHandle( hdb2 );
  72     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  73
  74     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  75     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  76
  77     res = MsiCloseHandle( hdb2 );
  78     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  79
  80     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile2 ), "uncommitted database should not exist\n");
  81
  82     res = MsiOpenDatabase( msifile, msifile2, &hdb2 );
  83     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  84
  85     res = MsiDatabaseCommit( hdb2 );
  86     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
  87
  88     res = MsiCloseHandle( hdb2 );
  89     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  90
  91     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile2 ), "committed database should exist\n");
  92
  93     res = MsiOpenDatabase( msifile, MSIDBOPEN_READONLY, &hdb );
  94     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
  95
  96     res = MsiCloseHandle( hdb );
  97     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
  98
  99     res = MsiOpenDatabase( msifile, MSIDBOPEN_DIRECT, &hdb );
 100     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 101
 102     res = MsiCloseHandle( hdb );
 103     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 104
 105     res = MsiOpenDatabase( msifile, MSIDBOPEN_TRANSACT, &hdb );
 106     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 107
 108     res = MsiCloseHandle( hdb );
 109     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 110     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 111
 112     /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
 113     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 114     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 115
 116     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 117
 118     res = MsiCloseHandle( hdb );
 119     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 120
 121     ok( INVALID_FILE_ATTRIBUTES == GetFileAttributes( msifile ), "database should exist\n");
 122
 123     res = MsiOpenDatabase( msifile, MSIDBOPEN_CREATE, &hdb );
 124     ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 125
 126     res = MsiDatabaseCommit( hdb );
 127     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 128
 129     ok( INVALID_FILE_ATTRIBUTES != GetFileAttributes( msifile ), "database should exist\n");
 130
 131     res = MsiCloseHandle( hdb );
 132     ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 133
 134     res = DeleteFile( msifile2 );
 135     ok( res == TRUE, "Failed to delete database\n" );
 136
 137     res = DeleteFile( msifile );
 138     ok( res == TRUE, "Failed to delete database\n" );
 139 }
 140
 141 static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
 142 {
 143     MSIHANDLE hview = 0;
 144     UINT r, ret;
 145
 146     /* open a select query */
 147     r = MsiDatabaseOpenView(hdb, query, &hview);
 148     if (r != ERROR_SUCCESS)
 149         return r;
 150     r = MsiViewExecute(hview, 0);
 151     if (r != ERROR_SUCCESS)
 152         return r;
 153     ret = MsiViewFetch(hview, phrec);
 154     r = MsiViewClose(hview);
 155     if (r != ERROR_SUCCESS)
 156         return r;
 157     r = MsiCloseHandle(hview);
 158     if (r != ERROR_SUCCESS)
 159         return r;
 160     return ret;
 161 }
 162
 163 static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
 164 {
 165     MSIHANDLE hview = 0;
 166     UINT r;
 167
 168     r = MsiDatabaseOpenView(hdb, query, &hview);
 169     if( r != ERROR_SUCCESS )
 170         return r;
 171
 172     r = MsiViewExecute(hview, hrec);
 173     if( r == ERROR_SUCCESS )
 174         r = MsiViewClose(hview);
 175     MsiCloseHandle(hview);
 176     return r;
 177 }
 178
 179 static UINT create_component_table( MSIHANDLE hdb )
 180 {
 181     return run_query( hdb, 0,
 182             "CREATE TABLE `Component` ( "
 183             "`Component` CHAR(72) NOT NULL, "
 184             "`ComponentId` CHAR(38), "
 185             "`Directory_` CHAR(72) NOT NULL, "
 186             "`Attributes` SHORT NOT NULL, "
 187             "`Condition` CHAR(255), "
 188             "`KeyPath` CHAR(72) "
 189             "PRIMARY KEY `Component`)" );
 190 }
 191
 192 static UINT create_feature_components_table( MSIHANDLE hdb )
 193 {
 194     return run_query( hdb, 0,
 195             "CREATE TABLE `FeatureComponents` ( "
 196             "`Feature_` CHAR(38) NOT NULL, "
 197             "`Component_` CHAR(72) NOT NULL "
 198             "PRIMARY KEY `Feature_`, `Component_` )" );
 199 }
 200
 201 static UINT create_std_dlls_table( MSIHANDLE hdb )
 202 {
 203     return run_query( hdb, 0,
 204             "CREATE TABLE `StdDlls` ( "
 205             "`File` CHAR(255) NOT NULL, "
 206             "`Binary_` CHAR(72) NOT NULL "
 207             "PRIMARY KEY `File` )" );
 208 }
 209
 210 static UINT create_binary_table( MSIHANDLE hdb )
 211 {
 212     return run_query( hdb, 0,
 213             "CREATE TABLE `Binary` ( "
 214             "`Name` CHAR(72) NOT NULL, "
 215             "`Data` CHAR(72) NOT NULL "
 216             "PRIMARY KEY `Name` )" );
 217 }
 218
 219 static UINT add_component_entry( MSIHANDLE hdb, const char *values )
 220 {
 221     char insert[] = "INSERT INTO `Component`  "
 222             "(`Component`, `ComponentId`, `Directory_`, `Attributes`, `Condition`, `KeyPath`) "
 223             "VALUES( %s )";
 224     char *query;
 225     UINT sz, r;
 226
 227     sz = strlen(values) + sizeof insert;
 228     query = HeapAlloc(GetProcessHeap(),0,sz);
 229     sprintf(query,insert,values);
 230     r = run_query( hdb, 0, query );
 231     HeapFree(GetProcessHeap(), 0, query);
 232     return r;
 233 }
 234
 235 static UINT add_feature_components_entry( MSIHANDLE hdb, const char *values )
 236 {
 237     char insert[] = "INSERT INTO `FeatureComponents` "
 238             "(`Feature_`, `Component_`) "
 239             "VALUES( %s )";
 240     char *query;
 241     UINT sz, r;
 242
 243     sz = strlen(values) + sizeof insert;
 244     query = HeapAlloc(GetProcessHeap(),0,sz);
 245     sprintf(query,insert,values);
 246     r = run_query( hdb, 0, query );
 247     HeapFree(GetProcessHeap(), 0, query);
 248     return r;
 249 }
 250
 251 static UINT add_std_dlls_entry( MSIHANDLE hdb, const char *values )
 252 {
 253     char insert[] = "INSERT INTO `StdDlls` "
 254             "(`File`, `Binary_`) "
 255             "VALUES( %s )";
 256     char *query;
 257     UINT sz, r;
 258
 259     sz = strlen(values) + sizeof insert;
 260     query = HeapAlloc(GetProcessHeap(),0,sz);
 261     sprintf(query,insert,values);
 262     r = run_query( hdb, 0, query );
 263     HeapFree(GetProcessHeap(), 0, query);
 264     return r;
 265 }
 266
 267 static UINT add_binary_entry( MSIHANDLE hdb, const char *values )
 268 {
 269     char insert[] = "INSERT INTO `Binary` "
 270             "(`Name`, `Data`) "
 271             "VALUES( %s )";
 272     char *query;
 273     UINT sz, r;
 274
 275     sz = strlen(values) + sizeof insert;
 276     query = HeapAlloc(GetProcessHeap(),0,sz);
 277     sprintf(query,insert,values);
 278     r = run_query( hdb, 0, query );
 279     HeapFree(GetProcessHeap(), 0, query);
 280     return r;
 281 }
 282
 283 static void test_msiinsert(void)
 284 {
 285     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 286     UINT r;
 287     const char *query;
 288     char buf[80];
 289     DWORD sz;
 290
 291     DeleteFile(msifile);
 292
 293     /* just MsiOpenDatabase should not create a file */
 294     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 295     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 296
 297     /* create a table */
 298     query = "CREATE TABLE `phone` ( "
 299             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 300             "PRIMARY KEY `id`)";
 301     r = MsiDatabaseOpenView(hdb, query, &hview);
 302     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 303     r = MsiViewExecute(hview, 0);
 304     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 305     r = MsiViewClose(hview);
 306     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 307     r = MsiCloseHandle(hview);
 308     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 309
 310     /* insert a value into it */
 311     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 312         "VALUES('1', 'Abe', '8675309')";
 313     r = MsiDatabaseOpenView(hdb, query, &hview);
 314     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 315     r = MsiViewExecute(hview, 0);
 316     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 317     r = MsiViewClose(hview);
 318     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 319     r = MsiCloseHandle(hview);
 320     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 321
 322     query = "SELECT * FROM `phone` WHERE `id` = 1";
 323     r = do_query(hdb, query, &hrec);
 324     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 325
 326     /* check the record contains what we put in it */
 327     r = MsiRecordGetFieldCount(hrec);
 328     ok(r == 3, "record count wrong\n");
 329
 330     todo_wine {
 331     r = MsiRecordIsNull(hrec, 0);
 332     ok(r == FALSE, "field 0 not null\n");
 333     }
 334
 335     r = MsiRecordGetInteger(hrec, 1);
 336     ok(r == 1, "field 1 contents wrong\n");
 337     sz = sizeof buf;
 338     r = MsiRecordGetString(hrec, 2, buf, &sz);
 339     ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
 340     ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
 341     sz = sizeof buf;
 342     r = MsiRecordGetString(hrec, 3, buf, &sz);
 343     ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
 344     ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 345
 346     r = MsiCloseHandle(hrec);
 347     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 348
 349     /* open a select query */
 350     hrec = 100;
 351     query = "SELECT * FROM `phone` WHERE `id` >= 10";
 352     r = do_query(hdb, query, &hrec);
 353     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 354     ok(hrec == 0, "hrec should be null\n");
 355
 356     r = MsiCloseHandle(hrec);
 357     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 358
 359     query = "SELECT * FROM `phone` WHERE `id` < 0";
 360     r = do_query(hdb, query, &hrec);
 361     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 362
 363     query = "SELECT * FROM `phone` WHERE `id` <= 0";
 364     r = do_query(hdb, query, &hrec);
 365     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 366
 367     query = "SELECT * FROM `phone` WHERE `id` <> 1";
 368     r = do_query(hdb, query, &hrec);
 369     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 370
 371     query = "SELECT * FROM `phone` WHERE `id` > 10";
 372     r = do_query(hdb, query, &hrec);
 373     ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 374
 375     /* now try a few bad INSERT xqueries */
 376     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 377         "VALUES(?, ?)";
 378     r = MsiDatabaseOpenView(hdb, query, &hview);
 379     ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 380
 381     /* construct a record to insert */
 382     hrec = MsiCreateRecord(4);
 383     r = MsiRecordSetInteger(hrec, 1, 2);
 384     ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 385     r = MsiRecordSetString(hrec, 2, "Adam");
 386     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 387     r = MsiRecordSetString(hrec, 3, "96905305");
 388     ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 389
 390     /* insert another value, using a record and wildcards */
 391     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
 392         "VALUES(?, ?, ?)";
 393     r = MsiDatabaseOpenView(hdb, query, &hview);
 394     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 395
 396     if (r == ERROR_SUCCESS)
 397     {
 398         r = MsiViewExecute(hview, hrec);
 399         ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 400         r = MsiViewClose(hview);
 401         ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 402         r = MsiCloseHandle(hview);
 403         ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 404     }
 405     r = MsiCloseHandle(hrec);
 406     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 407
 408     r = MsiViewFetch(0, NULL);
 409     ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 410
 411     r = MsiDatabaseCommit(hdb);
 412     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 413
 414     r = MsiCloseHandle(hdb);
 415     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 416
 417     r = DeleteFile(msifile);
 418     ok(r == TRUE, "file didn't exist after commit\n");
 419 }
 420
 421 typedef UINT (WINAPI *fnMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
 422 static fnMsiDecomposeDescriptorA pMsiDecomposeDescriptorA;
 423
 424 static void test_msidecomposedesc(void)
 425 {
 426     char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
 427     const char *desc;
 428     UINT r;
 429     DWORD len;
 430     HMODULE hmod;
 431
 432     hmod = GetModuleHandle("msi.dll");
 433     if (!hmod)
 434         return;
 435     pMsiDecomposeDescriptorA = (fnMsiDecomposeDescriptorA)
 436         GetProcAddress(hmod, "MsiDecomposeDescriptorA");
 437     if (!pMsiDecomposeDescriptorA)
 438         return;
 439
 440     /* test a valid feature descriptor */
 441     desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
 442     len = 0;
 443     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 444     ok(r == ERROR_SUCCESS, "returned an error\n");
 445     ok(len == strlen(desc), "length was wrong\n");
 446     ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
 447     ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
 448     ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 449
 450     /* test an invalid feature descriptor with too many characters */
 451     desc = "']gAVn-}f(ZXfeAR6.ji"
 452            "ThisWillFailIfTheresMoreThanAGuidsChars>"
 453            "3w2x^IGfe?CxI5heAvk.";
 454     len = 0;
 455     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 456     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 457
 458     /*
 459      * Test a valid feature descriptor with the
 460      * maximum number of characters and some trailing characters.
 461      */
 462     desc = "']gAVn-}f(ZXfeAR6.ji"
 463            "ThisWillWorkIfTheresLTEThanAGuidsChars>"
 464            "3w2x^IGfe?CxI5heAvk."
 465            "extra";
 466     len = 0;
 467     r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
 468     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 469     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 470
 471     len = 0;
 472     r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
 473     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 474     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 475
 476     len = 0;
 477     r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
 478     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 479     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 480
 481     len = 0;
 482     r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
 483     ok(r == ERROR_SUCCESS, "returned wrong error\n");
 484     ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 485
 486     len = 0;
 487     r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
 488     ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 489     ok(len == 0, "length wrong\n");
 490 }
 491
 492 static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
 493 {
 494     MSIHANDLE htab = 0;
 495     UINT res;
 496
 497     res = MsiDatabaseOpenView( hdb, szQuery, &htab );
 498     if(res == ERROR_SUCCESS )
 499     {
 500         UINT r;
 501
 502         r = MsiViewExecute( htab, hrec );
 503         if(r != ERROR_SUCCESS )
 504             res = r;
 505
 506         r = MsiViewClose( htab );
 507         if(r != ERROR_SUCCESS )
 508             res = r;
 509
 510         r = MsiCloseHandle( htab );
 511         if(r != ERROR_SUCCESS )
 512             res = r;
 513     }
 514     return res;
 515 }
 516
 517 static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
 518 {
 519     return try_query_param( hdb, szQuery, 0 );
 520 }
 521
 522 static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
 523 {
 524     MSIHANDLE hrec = 0;
 525     UINT r;
 526
 527     hrec = MsiCreateRecord( 1 );
 528     MsiRecordSetString( hrec, 1, "Hello");
 529
 530     r = try_query_param( hdb, szQuery, hrec );
 531
 532     MsiCloseHandle( hrec );
 533     return r;
 534 }
 535
 536 static void test_msibadqueries(void)
 537 {
 538     MSIHANDLE hdb = 0;
 539     UINT r;
 540
 541     DeleteFile(msifile);
 542
 543     /* just MsiOpenDatabase should not create a file */
 544     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 545     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 546
 547     r = MsiDatabaseCommit( hdb );
 548     ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 549
 550     r = MsiCloseHandle( hdb );
 551     ok(r == ERROR_SUCCESS , "Failed to close database\n");
 552
 553     /* open it readonly */
 554     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb );
 555     ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 556
 557     /* add a table to it */
 558     r = try_query( hdb, "select * from _Tables");
 559     ok(r == ERROR_SUCCESS , "query 1 failed\n");
 560
 561     r = MsiCloseHandle( hdb );
 562     ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 563
 564     /* open it read/write */
 565     r = MsiOpenDatabase(msifile, MSIDBOPEN_TRANSACT, &hdb );
 566     ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 567
 568     /* a bunch of test queries that fail with the native MSI */
 569
 570     r = try_query( hdb, "CREATE TABLE");
 571     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 572
 573     r = try_query( hdb, "CREATE TABLE `a`");
 574     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 575
 576     r = try_query( hdb, "CREATE TABLE `a` ()");
 577     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 578
 579     r = try_query( hdb, "CREATE TABLE `a` (`b`)");
 580     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 581
 582     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
 583     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 584
 585     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
 586     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 587
 588     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
 589     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 590
 591     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 592     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 593
 594     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
 595     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 596
 597     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
 598     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 599
 600     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 601     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 602
 603     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
 604     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 605
 606     r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
 607     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 608
 609     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
 610     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 611
 612     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
 613     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 614
 615     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
 616     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 617
 618     r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 619     ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 620
 621     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 622     ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 623
 624     r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
 625     ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 626
 627     r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
 628           "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
 629     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 630
 631     r = MsiDatabaseCommit( hdb );
 632     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 633
 634     r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
 635                           "PRIMARY KEY `foo`)");
 636     ok(r == ERROR_SUCCESS , "query 4 failed\n");
 637
 638     r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
 639     ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 640
 641     r = MsiDatabaseCommit( hdb );
 642     ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 643
 644     r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
 645                           "PRIMARY KEY `ba`)");
 646     ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 647
 648     r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
 649     ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 650
 651     r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
 652                           "PRIMARY KEY `t`)");
 653     ok(r == ERROR_SUCCESS , "query 7 failed\n");
 654
 655     r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
 656     ok(r == ERROR_SUCCESS , "query 8 failed\n");
 657
 658     r = MsiCloseHandle( hdb );
 659     ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 660
 661     r = DeleteFile( msifile );
 662     ok(r == TRUE, "file didn't exist after commit\n");
 663 }
 664
 665 static void test_viewmodify(void)
 666 {
 667     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
 668     UINT r;
 669     const char *query;
 670     char buffer[0x100];
 671     DWORD sz;
 672
 673     DeleteFile(msifile);
 674
 675     /* just MsiOpenDatabase should not create a file */
 676     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
 677     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 678
 679     query = "CREATE TABLE `phone` ( "
 680             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
 681             "PRIMARY KEY `id`)";
 682     r = run_query( hdb, 0, query );
 683     ok(r == ERROR_SUCCESS, "query failed\n");
 684
 685     /* check what the error function reports without doing anything */
 686     sz = 0;
 687     /* passing NULL as the 3rd param make function to crash on older platforms */
 688     r = MsiViewGetError( 0, NULL, &sz );
 689     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 690
 691     /* open a view */
 692     query = "SELECT * FROM `phone`";
 693     r = MsiDatabaseOpenView(hdb, query, &hview);
 694     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 695
 696     /* see what happens with a good hview and bad args */
 697     r = MsiViewGetError( hview, NULL, NULL );
 698     ok(r == MSIDBERROR_INVALIDARG || r == MSIDBERROR_NOERROR,
 699        "MsiViewGetError returns %u (expected -3)\n", r);
 700     r = MsiViewGetError( hview, buffer, NULL );
 701     ok(r == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
 702
 703     /* see what happens with a zero length buffer */
 704     sz = 0;
 705     buffer[0] = 'x';
 706     r = MsiViewGetError( hview, buffer, &sz );
 707     ok(r == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
 708     ok(buffer[0] == 'x', "buffer cleared\n");
 709     ok(sz == 0, "size not zero\n");
 710
 711     /* ok this one is strange */
 712     sz = 0;
 713     r = MsiViewGetError( hview, NULL, &sz );
 714     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 715     ok(sz == 0, "size not zero\n");
 716
 717     /* see if it really has an error */
 718     sz = sizeof buffer;
 719     buffer[0] = 'x';
 720     r = MsiViewGetError( hview, buffer, &sz );
 721     ok(r == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
 722     ok(buffer[0] == 0, "buffer not cleared\n");
 723     ok(sz == 0, "size not zero\n");
 724
 725     r = MsiViewExecute(hview, 0);
 726     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 727
 728     /* try some invalid records */
 729     r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
 730     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 731     r = MsiViewModify(hview, -1, 0 );
 732     ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 733
 734     /* try an small record */
 735     hrec = MsiCreateRecord(1);
 736     r = MsiViewModify(hview, -1, hrec );
 737     ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 738
 739     r = MsiCloseHandle(hrec);
 740     ok(r == ERROR_SUCCESS, "failed to close record\n");
 741
 742     /* insert a valid record */
 743     hrec = MsiCreateRecord(3);
 744
 745     r = MsiRecordSetInteger(hrec, 2, 1);
 746     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 747     r = MsiRecordSetString(hrec, 2, "bob");
 748     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 749     r = MsiRecordSetString(hrec, 3, "7654321");
 750     ok(r == ERROR_SUCCESS, "failed to set integer\n");
 751
 752     r = MsiViewExecute(hview, 0);
 753     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 754     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 755     ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 756
 757     /* insert the same thing again */
 758     r = MsiViewExecute(hview, 0);
 759     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 760
 761     /* should fail ... */
 762     todo_wine {
 763     r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
 764     ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 765     }
 766
 767     r = MsiCloseHandle(hrec);
 768     ok(r == ERROR_SUCCESS, "failed to close record\n");
 769
 770     r = MsiViewClose(hview);
 771     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
 772     r = MsiCloseHandle(hview);
 773     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 774
 775     r = MsiCloseHandle( hdb );
 776     ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
 777 }
 778
 779 static MSIHANDLE create_db(void)
 780 {
 781     MSIHANDLE hdb = 0;
 782     UINT res;
 783
 784     DeleteFile(msifile);
 785
 786     /* create an empty database */
 787     res = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb );
 788     ok( res == ERROR_SUCCESS , "Failed to create database\n" );
 789     if( res != ERROR_SUCCESS )
 790         return hdb;
 791
 792     res = MsiDatabaseCommit( hdb );
 793     ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 794
 795     return hdb;
 796 }
 797
 798 static void test_getcolinfo(void)
 799 {
 800     MSIHANDLE hdb, hview = 0, rec = 0;
 801     UINT r;
 802     DWORD sz;
 803     char buffer[0x20];
 804
 805     /* create an empty db */
 806     hdb = create_db();
 807     ok( hdb, "failed to create db\n");
 808
 809     /* tables should be present */
 810     r = MsiDatabaseOpenView(hdb, "select * from _Tables", &hview);
 811     ok( r == ERROR_SUCCESS, "failed to open query\n");
 812
 813     r = MsiViewExecute(hview, 0);
 814     ok( r == ERROR_SUCCESS, "failed to execute query\n");
 815
 816     /* check that NAMES works */
 817     rec = 0;
 818     r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
 819     ok( r == ERROR_SUCCESS, "failed to get names\n");
 820     sz = sizeof buffer;
 821     r = MsiRecordGetString(rec, 1, buffer, &sz );
 822     ok( r == ERROR_SUCCESS, "failed to get string\n");
 823     ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
 824     r = MsiCloseHandle( rec );
 825     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 826
 827     /* check that TYPES works */
 828     rec = 0;
 829     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
 830     ok( r == ERROR_SUCCESS, "failed to get names\n");
 831     sz = sizeof buffer;
 832     r = MsiRecordGetString(rec, 1, buffer, &sz );
 833     ok( r == ERROR_SUCCESS, "failed to get string\n");
 834     ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
 835     r = MsiCloseHandle( rec );
 836     ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 837
 838     /* check that invalid values fail */
 839     rec = 0;
 840     r = MsiViewGetColumnInfo( hview, 100, &rec );
 841     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 842     ok( rec == 0, "returned a record\n");
 843
 844     r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
 845     ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 846
 847     r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
 848     ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
 849
 850     r = MsiViewClose(hview);
 851     ok( r == ERROR_SUCCESS, "failed to close view\n");
 852     r = MsiCloseHandle(hview);
 853     ok( r == ERROR_SUCCESS, "failed to close view handle\n");
 854     r = MsiCloseHandle(hdb);
 855     ok( r == ERROR_SUCCESS, "failed to close database\n");
 856 }
 857
 858 static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
 859 {
 860     MSIHANDLE hview = 0, rec = 0;
 861     UINT r;
 862
 863     r = MsiDatabaseOpenView(hdb, query, &hview);
 864     if( r != ERROR_SUCCESS )
 865         return r;
 866
 867     r = MsiViewExecute(hview, 0);
 868     if( r == ERROR_SUCCESS )
 869     {
 870         MsiViewGetColumnInfo( hview, type, &rec );
 871         MsiViewClose(hview);
 872     }
 873     MsiCloseHandle(hview);
 874     return rec;
 875 }
 876
 877 static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
 878 {
 879     MSIHANDLE hview = 0, rec = 0;
 880     UINT r, type = 0;
 881     char query[0x100];
 882
 883     sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
 884
 885     r = MsiDatabaseOpenView(hdb, query, &hview);
 886     if( r != ERROR_SUCCESS )
 887         return r;
 888
 889     r = MsiViewExecute(hview, 0);
 890     if( r == ERROR_SUCCESS )
 891     {
 892         while (1)
 893         {
 894             r = MsiViewFetch( hview, &rec );
 895             if( r != ERROR_SUCCESS)
 896                 break;
 897             r = MsiRecordGetInteger( rec, 2 );
 898             if (r == field)
 899                 type = MsiRecordGetInteger( rec, 4 );
 900             MsiCloseHandle( rec );
 901         }
 902
 903         MsiViewClose(hview);
 904     }
 905     MsiCloseHandle(hview);
 906     return type;
 907 }
 908
 909 static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
 910 {
 911     CHAR buffer[0x20];
 912     UINT r;
 913     DWORD sz;
 914
 915     sz = sizeof buffer;
 916     r = MsiRecordGetString( rec, field, buffer, &sz );
 917     return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
 918 }
 919
 920 static void test_viewgetcolumninfo(void)
 921 {
 922     MSIHANDLE hdb = 0, rec;
 923     UINT r;
 924
 925     hdb = create_db();
 926     ok( hdb, "failed to create db\n");
 927
 928     r = run_query( hdb, 0,
 929             "CREATE TABLE `Properties` "
 930             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
 931     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 932
 933     /* check the column types */
 934     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
 935     ok( rec, "failed to get column info record\n" );
 936
 937     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 938     ok( check_record( rec, 2, "S1"), "wrong record type\n");
 939
 940     MsiCloseHandle( rec );
 941
 942     /* check the type in _Columns */
 943     ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
 944     ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
 945
 946     /* now try the names */
 947     rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
 948     ok( rec, "failed to get column info record\n" );
 949
 950     ok( check_record( rec, 1, "Property"), "wrong record type\n");
 951     ok( check_record( rec, 2, "Value"), "wrong record type\n");
 952
 953     MsiCloseHandle( rec );
 954
 955     r = run_query( hdb, 0,
 956             "CREATE TABLE `Binary` "
 957             "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
 958     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 959
 960     /* check the column types */
 961     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
 962     ok( rec, "failed to get column info record\n" );
 963
 964     ok( check_record( rec, 1, "S255"), "wrong record type\n");
 965     ok( check_record( rec, 2, "V0"), "wrong record type\n");
 966
 967     MsiCloseHandle( rec );
 968
 969     /* check the type in _Columns */
 970     ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
 971     ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
 972
 973     /* now try the names */
 974     rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
 975     ok( rec, "failed to get column info record\n" );
 976
 977     ok( check_record( rec, 1, "Name"), "wrong record type\n");
 978     ok( check_record( rec, 2, "Data"), "wrong record type\n");
 979     MsiCloseHandle( rec );
 980
 981     r = run_query( hdb, 0,
 982             "CREATE TABLE `UIText` "
 983             "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
 984     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 985
 986     ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
 987     ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
 988
 989     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
 990     ok( rec, "failed to get column info record\n" );
 991     ok( check_record( rec, 1, "Key"), "wrong record type\n");
 992     ok( check_record( rec, 2, "Text"), "wrong record type\n");
 993     MsiCloseHandle( rec );
 994
 995     rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
 996     ok( rec, "failed to get column info record\n" );
 997     ok( check_record( rec, 1, "s72"), "wrong record type\n");
 998     ok( check_record( rec, 2, "L255"), "wrong record type\n");
 999     MsiCloseHandle( rec );
1000
1001     MsiCloseHandle( hdb );
1002 }
1003
1004 static void test_msiexport(void)
1005 {
1006     MSIHANDLE hdb = 0, hview = 0;
1007     UINT r;
1008     const char *query;
1009     char path[MAX_PATH];
1010     const char file[] = "phone.txt";
1011     HANDLE handle;
1012     char buffer[0x100];
1013     DWORD length;
1014     const char expected[] =
1015         "id\tname\tnumber\r\n"
1016         "I2\tS32\tS32\r\n"
1017         "phone\tid\r\n"
1018         "1\tAbe\t8675309\r\n";
1019
1020     DeleteFile(msifile);
1021
1022     /* just MsiOpenDatabase should not create a file */
1023     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1024     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1025
1026     /* create a table */
1027     query = "CREATE TABLE `phone` ( "
1028             "`id` INT, `name` CHAR(32), `number` CHAR(32) "
1029             "PRIMARY KEY `id`)";
1030     r = MsiDatabaseOpenView(hdb, query, &hview);
1031     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1032     r = MsiViewExecute(hview, 0);
1033     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1034     r = MsiViewClose(hview);
1035     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1036     r = MsiCloseHandle(hview);
1037     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1038
1039     /* insert a value into it */
1040     query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
1041         "VALUES('1', 'Abe', '8675309')";
1042     r = MsiDatabaseOpenView(hdb, query, &hview);
1043     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1044     r = MsiViewExecute(hview, 0);
1045     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1046     r = MsiViewClose(hview);
1047     ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
1048     r = MsiCloseHandle(hview);
1049     ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
1050
1051     GetCurrentDirectory(MAX_PATH, path);
1052
1053     r = MsiDatabaseExport(hdb, "phone", path, file);
1054     ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
1055
1056     MsiCloseHandle(hdb);
1057
1058     lstrcat(path, "\\");
1059     lstrcat(path, file);
1060
1061     /* check the data that was written */
1062     length = 0;
1063     memset(buffer, 0, sizeof buffer);
1064     handle = CreateFile(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
1065     if (handle != INVALID_HANDLE_VALUE)
1066     {
1067         ReadFile(handle, buffer, sizeof buffer, &length, NULL);
1068         CloseHandle(handle);
1069         DeleteFile(path);
1070     }
1071     else
1072         ok(0, "failed to open file %s\n", path);
1073
1074     ok( length == strlen(expected), "length of data wrong\n");
1075     ok( !lstrcmp(buffer, expected), "data doesn't match\n");
1076     DeleteFile(msifile);
1077 }
1078
1079 static void test_longstrings(void)
1080 {
1081     const char insert_query[] =
1082         "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
1083     char *str;
1084     MSIHANDLE hdb = 0, hview = 0, hrec = 0;
1085     DWORD len;
1086     UINT r;
1087     const DWORD STRING_LENGTH = 0x10005;
1088
1089     DeleteFile(msifile);
1090     /* just MsiOpenDatabase should not create a file */
1091     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb);
1092     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1093
1094     /* create a table */
1095     r = try_query( hdb,
1096         "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
1097     ok(r == ERROR_SUCCESS, "query failed\n");
1098
1099     /* try a insert a very long string */
1100     str = HeapAlloc(GetProcessHeap(), 0, STRING_LENGTH+sizeof insert_query);
1101     len = strchr(insert_query, 'Z') - insert_query;
1102     strcpy(str, insert_query);
1103     memset(str+len, 'Z', STRING_LENGTH);
1104     strcpy(str+len+STRING_LENGTH, insert_query+len+1);
1105     r = try_query( hdb, str );
1106     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1107
1108     HeapFree(GetProcessHeap(), 0, str);
1109
1110     MsiDatabaseCommit(hdb);
1111     ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
1112     MsiCloseHandle(hdb);
1113
1114     r = MsiOpenDatabase(msifile, MSIDBOPEN_READONLY, &hdb);
1115     ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
1116
1117     r = MsiDatabaseOpenView(hdb, "select * from `strings` where `id` = 1", &hview);
1118     ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
1119
1120     r = MsiViewExecute(hview, 0);
1121     ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
1122
1123     r = MsiViewFetch(hview, &hrec);
1124     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1125
1126     MsiCloseHandle(hview);
1127
1128     r = MsiRecordGetString(hrec, 2, NULL, &len);
1129     ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
1130     ok(len == STRING_LENGTH, "string length wrong\n");
1131
1132     MsiCloseHandle(hrec);
1133     MsiCloseHandle(hdb);
1134     DeleteFile(msifile);
1135 }
1136
1137 static void create_file(const CHAR *name)
1138 {
1139     HANDLE file;
1140     DWORD written;
1141
1142     file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
1143     ok(file != INVALID_HANDLE_VALUE, "Failure to open file %s\n", name);
1144     WriteFile(file, name, strlen(name), &written, NULL);
1145     WriteFile(file, "\n", strlen("\n"), &written, NULL);
1146     CloseHandle(file);
1147 }
1148
1149 static void test_streamtable(void)
1150 {
1151     MSIHANDLE hdb = 0, rec, view;
1152     char file[MAX_PATH];
1153     char buf[MAX_PATH];
1154     DWORD size;
1155     UINT r;
1156
1157     hdb = create_db();
1158     ok( hdb, "failed to create db\n");
1159
1160     r = run_query( hdb, 0,
1161             "CREATE TABLE `Properties` "
1162             "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
1163     ok( r == ERROR_SUCCESS , "Failed to create table\n" );
1164
1165     /* check the column types */
1166     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
1167     ok( rec, "failed to get column info record\n" );
1168
1169     todo_wine {
1170     ok( check_record( rec, 1, "s62"), "wrong record type\n");
1171     ok( check_record( rec, 2, "V0"), "wrong record type\n");
1172     }
1173
1174     MsiCloseHandle( rec );
1175
1176     /* now try the names */
1177     rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
1178     ok( rec, "failed to get column info record\n" );
1179
1180     todo_wine {
1181     ok( check_record( rec, 1, "Name"), "wrong record type\n");
1182     ok( check_record( rec, 2, "Data"), "wrong record type\n");
1183     }
1184
1185     MsiCloseHandle( rec );
1186
1187     /* insert a file into the _Streams table */
1188     create_file( "test.txt" );
1189
1190     rec = MsiCreateRecord( 2 );
1191     MsiRecordSetString( rec, 1, "data" );
1192
1193     r = MsiRecordSetStream( rec, 2, "test.txt" );
1194     ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
1195
1196     DeleteFile("test.txt");
1197
1198     r = MsiDatabaseOpenView( hdb,
1199             "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
1200     todo_wine
1201     {
1202         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1203     }
1204
1205     r = MsiViewExecute( view, rec );
1206     todo_wine
1207     {
1208         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1209     }
1210
1211     MsiCloseHandle( rec );
1212     MsiCloseHandle( view );
1213
1214     r = MsiDatabaseOpenView( hdb,
1215             "SELECT `Name`, `Data` FROM `_Streams`", &view );
1216     todo_wine
1217     {
1218         ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
1219     }
1220
1221     r = MsiViewExecute( view, 0 );
1222     todo_wine
1223     {
1224         ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
1225     }
1226
1227     r = MsiViewFetch( view, &rec );
1228     todo_wine
1229     {
1230         ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
1231     }
1232
1233     size = MAX_PATH;
1234     r = MsiRecordGetString( rec, 1, file, &size );
1235     todo_wine
1236     {
1237         ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
1238         ok( !lstrcmp(file, "data"), "Expected 'data', got %s\n", file);
1239     }
1240
1241     size = MAX_PATH;
1242     memset(buf, 0, MAX_PATH);
1243     r = MsiRecordReadStream( rec, 2, buf, &size );
1244     todo_wine
1245     {
1246         ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
1247         ok( !lstrcmp(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
1248     }
1249
1250     MsiCloseHandle( rec );
1251
1252     r = MsiViewFetch( view, &rec );
1253     todo_wine
1254     {
1255         ok( r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
1256     }
1257
1258     MsiCloseHandle( view );
1259     MsiCloseHandle( hdb );
1260     DeleteFile(msifile);
1261 }
1262
1263 static void test_where(void)
1264 {
1265     MSIHANDLE hdb = 0, rec, view;
1266     LPCSTR query;
1267     UINT r;
1268     DWORD size;
1269     CHAR buf[MAX_PATH];
1270     UINT count;
1271
1272     hdb = create_db();
1273     ok( hdb, "failed to create db\n");
1274
1275     r = run_query( hdb, 0,
1276             "CREATE TABLE `Media` ("
1277             "`DiskId` SHORT NOT NULL, "
1278             "`LastSequence` LONG, "
1279             "`DiskPrompt` CHAR(64) LOCALIZABLE, "
1280             "`Cabinet` CHAR(255), "
1281             "`VolumeLabel` CHAR(32), "
1282             "`Source` CHAR(72) "
1283             "PRIMARY KEY `DiskId`)" );
1284     ok( r == S_OK, "cannot create Media table: %d\n", r );
1285
1286     r = run_query( hdb, 0, "INSERT INTO `Media` "
1287             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1288             "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
1289     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1290
1291     r = run_query( hdb, 0, "INSERT INTO `Media` "
1292             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1293             "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
1294     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1295
1296     r = run_query( hdb, 0, "INSERT INTO `Media` "
1297             "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
1298             "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
1299     ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
1300
1301     query = "SELECT * FROM `Media`";
1302     r = do_query(hdb, query, &rec);
1303     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1304     ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
1305     MsiCloseHandle( rec );
1306
1307     query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
1308     r = do_query(hdb, query, &rec);
1309     ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
1310     ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
1311
1312     r = MsiRecordGetInteger(rec, 1);
1313     ok( 2 == r, "field wrong\n");
1314     r = MsiRecordGetInteger(rec, 2);
1315     ok( 1 == r, "field wrong\n");
1316     MsiCloseHandle( rec );
1317
1318     query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
1319     r = MsiDatabaseOpenView(hdb, query, &view);
1320     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1321
1322     r = MsiViewExecute(view, 0);
1323     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1324
1325     r = MsiViewFetch(view, &rec);
1326     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1327
1328     count = MsiRecordGetFieldCount( rec );
1329     ok( count == 1, "Expected 1 record fields, got %d\n", count );
1330
1331     size = MAX_PATH;
1332     r = MsiRecordGetString( rec, 1, buf, &size );
1333     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1334     ok( !lstrcmp( buf, "2" ),
1335         "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
1336     MsiCloseHandle( rec );
1337
1338     r = MsiViewFetch(view, &rec);
1339     ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
1340
1341     size = MAX_PATH;
1342     r = MsiRecordGetString( rec, 1, buf, &size );
1343     ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1344     ok( !lstrcmp( buf, "3" ),
1345         "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
1346     MsiCloseHandle( rec );
1347
1348     r = MsiViewFetch(view, &rec);
1349     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1350
1351     MsiViewClose(view);
1352     MsiCloseHandle(view);
1353
1354     MsiCloseHandle( rec );
1355
1356     MsiCloseHandle( hdb );
1357     DeleteFile(msifile);
1358 }
1359
1360 static CHAR CURR_DIR[MAX_PATH];
1361
1362 static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
1363                                 "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
1364                                 "TestTable\tFirstPrimaryColumn\n"
1365                                 "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
1366
1367 static void write_file(const CHAR *filename, const char *data, int data_size)
1368 {
1369     DWORD size;
1370
1371     HANDLE hf = CreateFile(filename, GENERIC_WRITE, 0, NULL,
1372                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1373
1374     WriteFile(hf, data, data_size, &size, NULL);
1375     CloseHandle(hf);
1376 }
1377
1378 static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
1379 {
1380     UINT r;
1381
1382     write_file("temp_file", table_data, (lstrlen(table_data) - 1) * sizeof(char));
1383     r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
1384     DeleteFileA("temp_file");
1385
1386     return r;
1387 }
1388
1389 static void test_msiimport(void)
1390 {
1391     MSIHANDLE hdb, view, rec;
1392     LPCSTR query;
1393     UINT r, count;
1394     signed int i;
1395
1396     GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
1397
1398     r = MsiOpenDatabaseA(msifile, MSIDBOPEN_CREATE, &hdb);
1399     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1400
1401     r = add_table_to_db(hdb, test_data);
1402     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1403
1404     query = "SELECT * FROM `TestTable`";
1405     r = MsiDatabaseOpenView(hdb, query, &view);
1406     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1407
1408     r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
1409     count = MsiRecordGetFieldCount(rec);
1410     ok(count == 9, "Expected 9, got %d\n", count);
1411     ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
1412     ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
1413     ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
1414     ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
1415     ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
1416     ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
1417     ok(check_record(rec, 7, "String"), "Expected String\n");
1418     ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
1419     ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
1420     MsiCloseHandle(rec);
1421
1422     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
1423     count = MsiRecordGetFieldCount(rec);
1424     ok(count == 9, "Expected 9, got %d\n", count);
1425     ok(check_record(rec, 1, "s255"), "Expected s255\n");
1426     ok(check_record(rec, 4, "I2"), "Expected I2\n");
1427     ok(check_record(rec, 6, "I4"), "Expected I4\n");
1428     ok(check_record(rec, 7, "S255"), "Expected S255\n");
1429     ok(check_record(rec, 8, "S0"), "Expected S0\n");
1430     ok(check_record(rec, 9, "s0"), "Expected s0\n");
1431     todo_wine
1432     {
1433         ok(check_record(rec, 2, "i2"), "Expected i2\n");
1434         ok(check_record(rec, 3, "i2"), "Expected i2\n");
1435         ok(check_record(rec, 5, "i4"), "Expected i4\n");
1436     }
1437     MsiCloseHandle(rec);
1438
1439     query = "SELECT * FROM `TestTable`";
1440     r = do_query(hdb, query, &rec);
1441     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1442     ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
1443     ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
1444     ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
1445     ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
1446
1447     i = MsiRecordGetInteger(rec, 2);
1448     ok(i == 5, "Expected 5, got %d\n", i);
1449
1450     i = MsiRecordGetInteger(rec, 3);
1451     ok(i == 2, "Expected 2, got %d\n", i);
1452
1453     i = MsiRecordGetInteger(rec, 4);
1454     todo_wine
1455     {
1456         ok(i == 0x80000000, "Expected 0x80000000, got %d\n", i);
1457     }
1458
1459     i = MsiRecordGetInteger(rec, 5);
1460     ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
1461
1462     i = MsiRecordGetInteger(rec, 6);
1463     ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
1464
1465     MsiCloseHandle(rec);
1466     MsiCloseHandle(view);
1467     MsiCloseHandle(hdb);
1468     DeleteFileA(msifile);
1469 }
1470
1471 static void test_markers(void)
1472 {
1473     MSIHANDLE hdb, rec;
1474     LPCSTR query;
1475     UINT r;
1476
1477     hdb = create_db();
1478     ok( hdb, "failed to create db\n");
1479
1480     rec = MsiCreateRecord(3);
1481     MsiRecordSetString(rec, 1, "Table");
1482     MsiRecordSetString(rec, 2, "Apples");
1483     MsiRecordSetString(rec, 3, "Oranges");
1484
1485     /* try a legit create */
1486     query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1487     r = run_query(hdb, 0, query);
1488     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1489     MsiCloseHandle(rec);
1490
1491     /* try table name as marker */
1492     rec = MsiCreateRecord(1);
1493     MsiRecordSetString(rec, 1, "Fable");
1494     query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1495     r = run_query(hdb, rec, query);
1496     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1497
1498     /* verify that we just created a table called '?', not 'Fable' */
1499     r = try_query(hdb, "SELECT * from `Fable`");
1500     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1501
1502     r = try_query(hdb, "SELECT * from `?`");
1503     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1504
1505     /* try table name as marker without backticks */
1506     MsiRecordSetString(rec, 1, "Mable");
1507     query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1508     r = run_query(hdb, rec, query);
1509     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1510
1511     /* try one column name as marker */
1512     MsiRecordSetString(rec, 1, "One");
1513     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
1514     r = run_query(hdb, rec, query);
1515     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1516     MsiCloseHandle(rec);
1517
1518     /* try column names as markers */
1519     rec = MsiCreateRecord(2);
1520     MsiRecordSetString(rec, 1, "One");
1521     MsiRecordSetString(rec, 2, "Two");
1522     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
1523     r = run_query(hdb, rec, query);
1524     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1525     MsiCloseHandle(rec);
1526
1527     /* try names with backticks */
1528     rec = MsiCreateRecord(3);
1529     MsiRecordSetString(rec, 1, "One");
1530     MsiRecordSetString(rec, 2, "Two");
1531     MsiRecordSetString(rec, 3, "One");
1532     query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1533     r = run_query(hdb, rec, query);
1534     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1535
1536     /* try names with backticks, minus definitions */
1537     query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
1538     r = run_query(hdb, rec, query);
1539     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1540
1541     /* try names without backticks */
1542     query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
1543     r = run_query(hdb, rec, query);
1544     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1545     MsiCloseHandle(rec);
1546
1547     /* try one long marker */
1548     rec = MsiCreateRecord(1);
1549     MsiRecordSetString(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
1550     query = "CREATE TABLE `Mable` ( ? )";
1551     r = run_query(hdb, rec, query);
1552     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1553     MsiCloseHandle(rec);
1554
1555     /* try all names as markers */
1556     rec = MsiCreateRecord(4);
1557     MsiRecordSetString(rec, 1, "Mable");
1558     MsiRecordSetString(rec, 2, "One");
1559     MsiRecordSetString(rec, 3, "Two");
1560     MsiRecordSetString(rec, 4, "One");
1561     query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
1562     r = run_query(hdb, rec, query);
1563     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1564     MsiCloseHandle(rec);
1565
1566     /* try a legit insert */
1567     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
1568     r = run_query(hdb, 0, query);
1569     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1570
1571     r = try_query(hdb, "SELECT * from `Table`");
1572     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1573
1574     /* try values as markers */
1575     rec = MsiCreateRecord(2);
1576     MsiRecordSetInteger(rec, 1, 4);
1577     MsiRecordSetString(rec, 2, "hi");
1578     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1579     r = run_query(hdb, rec, query);
1580     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1581     MsiCloseHandle(rec);
1582
1583     /* try column names and values as markers */
1584     rec = MsiCreateRecord(4);
1585     MsiRecordSetString(rec, 1, "One");
1586     MsiRecordSetString(rec, 2, "Two");
1587     MsiRecordSetInteger(rec, 3, 5);
1588     MsiRecordSetString(rec, 4, "hi");
1589     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
1590     r = run_query(hdb, rec, query);
1591     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1592     MsiCloseHandle(rec);
1593
1594     /* try column names as markers */
1595     rec = MsiCreateRecord(2);
1596     MsiRecordSetString(rec, 1, "One");
1597     MsiRecordSetString(rec, 2, "Two");
1598     query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
1599     r = run_query(hdb, rec, query);
1600     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1601     MsiCloseHandle(rec);
1602
1603     /* try table name as a marker */
1604     rec = MsiCreateRecord(1);
1605     MsiRecordSetString(rec, 1, "Table");
1606     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
1607     r = run_query(hdb, rec, query);
1608     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1609     MsiCloseHandle(rec);
1610
1611     /* try table name and values as markers */
1612     rec = MsiCreateRecord(3);
1613     MsiRecordSetString(rec, 1, "Table");
1614     MsiRecordSetInteger(rec, 2, 10);
1615     MsiRecordSetString(rec, 3, "haha");
1616     query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
1617     r = run_query(hdb, rec, query);
1618     ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
1619     MsiCloseHandle(rec);
1620
1621     /* try all markers */
1622     rec = MsiCreateRecord(5);
1623     MsiRecordSetString(rec, 1, "Table");
1624     MsiRecordSetString(rec, 1, "One");
1625     MsiRecordSetString(rec, 1, "Two");
1626     MsiRecordSetInteger(rec, 2, 10);
1627     MsiRecordSetString(rec, 3, "haha");
1628     query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
1629     r = run_query(hdb, rec, query);
1630     ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
1631     MsiCloseHandle(rec);
1632
1633     /* insert an integer as a string */
1634     rec = MsiCreateRecord(2);
1635     MsiRecordSetString(rec, 1, "11");
1636     MsiRecordSetString(rec, 2, "hi");
1637     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
1638     r = run_query(hdb, rec, query);
1639     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1640     MsiCloseHandle(rec);
1641
1642     /* leave off the '' for the string */
1643     rec = MsiCreateRecord(2);
1644     MsiRecordSetInteger(rec, 1, 12);
1645     MsiRecordSetString(rec, 2, "hi");
1646     query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
1647     r = run_query(hdb, rec, query);
1648     ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
1649     MsiCloseHandle(rec);
1650
1651     MsiCloseHandle(hdb);
1652     DeleteFileA(msifile);
1653 }
1654
1655 #define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2k */
1656 static void test_handle_limit(void)
1657 {
1658     int i;
1659     MSIHANDLE hdb;
1660     MSIHANDLE hviews[MY_NVIEWS];
1661     UINT r;
1662
1663     /* create an empty db */
1664     hdb = create_db();
1665     ok( hdb, "failed to create db\n");
1666
1667     memset(hviews, 0, sizeof(hviews));
1668
1669     for (i=0; i<MY_NVIEWS; i++) {
1670         static char szQueryBuf[256] = "SELECT * from `_Tables`";
1671         hviews[i] = 0xdeadbeeb;
1672         r = MsiDatabaseOpenView(hdb, szQueryBuf, &hviews[i]);
1673         if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
1674             hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
1675             break;
1676     }
1677
1678     ok( i == MY_NVIEWS, "problem opening views\n");
1679
1680     for (i=0; i<MY_NVIEWS; i++) {
1681         if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
1682             r = MsiCloseHandle(hviews[i]);
1683             if (r != ERROR_SUCCESS)
1684                 break;
1685         }
1686     }
1687
1688     ok( i == MY_NVIEWS, "problem closing views\n");
1689
1690     r = MsiCloseHandle(hdb);
1691     ok( r == ERROR_SUCCESS, "failed to close database\n");
1692 }
1693
1694 static void test_generate_transform(void)
1695 {
1696     MSIHANDLE hdb1, hdb2;
1697     LPCSTR query;
1698     UINT r;
1699
1700     DeleteFile(msifile);
1701     DeleteFile(msifile2);
1702     DeleteFile(mstfile);
1703
1704     /* create an empty database */
1705     r = MsiOpenDatabase(msifile, MSIDBOPEN_CREATE, &hdb1 );
1706     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1707
1708     r = MsiDatabaseCommit( hdb1 );
1709     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1710
1711     /* create another empty database */
1712     r = MsiOpenDatabase(msifile2, MSIDBOPEN_CREATE, &hdb2 );
1713     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1714
1715     r = MsiDatabaseCommit( hdb2 );
1716     ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
1717
1718     /* the transform between two empty database should be empty */
1719     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1720     todo_wine {
1721     ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
1722     }
1723
1724     query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
1725     r = run_query(hdb1, 0, query);
1726     ok(r == ERROR_SUCCESS, "failed to add table\n");
1727
1728     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
1729     r = run_query(hdb1, 0, query);
1730     ok(r == ERROR_SUCCESS, "failed to add row 1\n");
1731
1732     query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
1733     r = run_query(hdb1, 0, query);
1734     ok(r == ERROR_SUCCESS, "failed to add row 2\n");
1735
1736     todo_wine {
1737     r = MsiDatabaseGenerateTransform(hdb1, hdb2, NULL, 0, 0);
1738     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1739
1740     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
1741     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1742
1743     /* database needs to be committed */
1744     MsiDatabaseCommit(hdb1);
1745
1746     r = MsiDatabaseGenerateTransform(hdb1, hdb2, mstfile, 0, 0);
1747     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1748
1749     MsiCloseHandle( hdb1 );
1750
1751     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1752     ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
1753
1754     MsiDatabaseCommit(hdb2);
1755
1756     /* apply the same transform again? */
1757     r = MsiDatabaseApplyTransform( hdb2, mstfile, 0 );
1758     ok( r == ERROR_INSTALL_TRANSFORM_FAILURE,
1759        "return code %d, should be ERROR_INSTALL_TRANSFORM_FAILURE\n", r );
1760     }
1761
1762     MsiCloseHandle( hdb2 );
1763
1764     DeleteFile(msifile);
1765
1766     r = MsiOpenDatabase(msifile2, MSIDBOPEN_READONLY, &hdb1 );
1767     ok( r == ERROR_SUCCESS , "Failed to create database\n" );
1768
1769     todo_wine {
1770     query = "select `BAR`,`CAR` from `AAR`";
1771     r = run_query(hdb1, 0, query);
1772     ok(r == ERROR_SUCCESS, "select query failed\n");
1773     }
1774
1775     MsiCloseHandle( hdb1 );
1776
1777     DeleteFile(msifile2);
1778     DeleteFile(mstfile);
1779 }
1780
1781 struct join_res
1782 {
1783     const CHAR one[MAX_PATH];
1784     const CHAR two[MAX_PATH];
1785 };
1786
1787 struct join_res_4col
1788 {
1789     const CHAR one[MAX_PATH];
1790     const CHAR two[MAX_PATH];
1791     const CHAR three[MAX_PATH];
1792     const CHAR four[MAX_PATH];
1793 };
1794
1795 static const struct join_res join_res_first[] =
1796 {
1797     { "alveolar", "procerus" },
1798     { "septum", "procerus" },
1799     { "septum", "nasalis" },
1800     { "ramus", "nasalis" },
1801     { "malar", "mentalis" },
1802 };
1803
1804 static const struct join_res join_res_second[] =
1805 {
1806     { "nasal", "septum" },
1807     { "mandible", "ramus" },
1808 };
1809
1810 static const struct join_res join_res_third[] =
1811 {
1812     { "msvcp.dll", "abcdefgh" },
1813     { "msvcr.dll", "ijklmnop" },
1814 };
1815
1816 static const struct join_res join_res_fourth[] =
1817 {
1818     { "msvcp.dll.01234", "single.dll.31415" },
1819 };
1820
1821 static const struct join_res join_res_fifth[] =
1822 {
1823     { "malar", "procerus" },
1824 };
1825
1826 static const struct join_res join_res_sixth[] =
1827 {
1828     { "malar", "procerus" },
1829     { "malar", "procerus" },
1830     { "malar", "nasalis" },
1831     { "malar", "nasalis" },
1832     { "malar", "nasalis" },
1833     { "malar", "mentalis" },
1834 };
1835
1836 static const struct join_res join_res_seventh[] =
1837 {
1838     { "malar", "nasalis" },
1839     { "malar", "nasalis" },
1840     { "malar", "nasalis" },
1841 };
1842
1843 static const struct join_res_4col join_res_eighth[] =
1844 {
1845     { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
1846     { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
1847     { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
1848     { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
1849     { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
1850     { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
1851 };
1852
1853 static void test_join(void)
1854 {
1855     MSIHANDLE hdb, hview, hrec;
1856     LPCSTR query;
1857     CHAR buf[MAX_PATH];
1858     UINT r, count;
1859     DWORD size, i;
1860
1861     hdb = create_db();
1862     ok( hdb, "failed to create db\n");
1863
1864     r = create_component_table( hdb );
1865     ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
1866
1867     r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
1868     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1869
1870     r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
1871     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1872
1873     r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
1874     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1875
1876     r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
1877     ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
1878
1879     r = create_feature_components_table( hdb );
1880     ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
1881
1882     r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
1883     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1884
1885     r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
1886     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1887
1888     r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
1889     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1890
1891     r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
1892     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1893
1894     r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
1895     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1896
1897     r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
1898     ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
1899
1900     r = create_std_dlls_table( hdb );
1901     ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
1902
1903     r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
1904     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
1905
1906     r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
1907     ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
1908
1909     r = create_binary_table( hdb );
1910     ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
1911
1912     r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
1913     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1914
1915     r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
1916     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1917
1918     r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
1919     ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
1920
1921     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
1922             "FROM `Component`, `FeatureComponents` "
1923             "WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
1924             "ORDER BY `Feature_`";
1925     r = MsiDatabaseOpenView(hdb, query, &hview);
1926     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1927
1928     r = MsiViewExecute(hview, 0);
1929     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1930
1931     i = 0;
1932     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1933     {
1934         count = MsiRecordGetFieldCount( hrec );
1935         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1936
1937         size = MAX_PATH;
1938         r = MsiRecordGetString( hrec, 1, buf, &size );
1939         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1940         if (i == 2 || i == 3) todo_wine
1941         {
1942             ok( !lstrcmp( buf, join_res_first[i].one ),
1943                 "For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
1944         }
1945
1946         size = MAX_PATH;
1947         r = MsiRecordGetString( hrec, 2, buf, &size );
1948         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1949         if (i == 3) todo_wine
1950         {
1951             ok( !lstrcmp( buf, join_res_first[i].two ),
1952                 "For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
1953         }
1954
1955         i++;
1956         MsiCloseHandle(hrec);
1957     }
1958
1959     todo_wine
1960     {
1961         ok( i == 5, "Expected 5 rows, got %d\n", i );
1962     }
1963
1964     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
1965
1966     MsiViewClose(hview);
1967     MsiCloseHandle(hview);
1968
1969     query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
1970             "WHERE FeatureComponents.Component_=Component.Component "
1971             "AND (Feature_='nasalis') ORDER BY Feature_";
1972     r = MsiDatabaseOpenView(hdb, query, &hview);
1973     todo_wine
1974     {
1975         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
1976     }
1977
1978     r = MsiViewExecute(hview, 0);
1979     todo_wine
1980     {
1981         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
1982     }
1983
1984     i = 0;
1985     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
1986     {
1987         count = MsiRecordGetFieldCount( hrec );
1988         ok( count == 2, "Expected 2 record fields, got %d\n", count );
1989
1990         size = MAX_PATH;
1991         r = MsiRecordGetString( hrec, 1, buf, &size );
1992         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1993         ok( !lstrcmp( buf, join_res_second[i].one ),
1994             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_second[i].one, buf );
1995
1996         size = MAX_PATH;
1997         r = MsiRecordGetString( hrec, 2, buf, &size );
1998         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
1999         ok( !lstrcmp( buf, join_res_second[i].two ),
2000             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_second[i].two, buf );
2001
2002         i++;
2003         MsiCloseHandle(hrec);
2004     }
2005
2006     todo_wine
2007     {
2008         ok( i == 2, "Expected 2 rows, got %d\n", i );
2009     }
2010
2011     todo_wine
2012     {
2013         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2014     }
2015
2016     MsiViewClose(hview);
2017     MsiCloseHandle(hview);
2018
2019     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2020             "FROM `StdDlls`, `Binary` "
2021             "WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
2022             "ORDER BY `File`";
2023     r = MsiDatabaseOpenView(hdb, query, &hview);
2024     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2025
2026     r = MsiViewExecute(hview, 0);
2027     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2028
2029     i = 0;
2030     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2031     {
2032         count = MsiRecordGetFieldCount( hrec );
2033         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2034
2035         size = MAX_PATH;
2036         r = MsiRecordGetString( hrec, 1, buf, &size );
2037         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2038         ok( !lstrcmp( buf, join_res_third[i].one ),
2039             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_third[i].one, buf );
2040
2041         size = MAX_PATH;
2042         r = MsiRecordGetString( hrec, 2, buf, &size );
2043         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2044         ok( !lstrcmp( buf, join_res_third[i].two ),
2045             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_third[i].two, buf );
2046
2047         i++;
2048         MsiCloseHandle(hrec);
2049     }
2050
2051     ok( i == 2, "Expected 2 rows, got %d\n", i );
2052
2053     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2054
2055     MsiViewClose(hview);
2056     MsiCloseHandle(hview);
2057
2058     query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
2059             "FROM `StdDlls`, `Binary` "
2060             "WHERE `StdDlls`.`File` = `Binary`.`Data` "
2061             "ORDER BY `Name`";
2062     r = MsiDatabaseOpenView(hdb, query, &hview);
2063     ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2064
2065     r = MsiViewExecute(hview, 0);
2066     ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2067
2068     i = 0;
2069     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2070     {
2071         count = MsiRecordGetFieldCount( hrec );
2072         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2073
2074         size = MAX_PATH;
2075         r = MsiRecordGetString( hrec, 1, buf, &size );
2076         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2077         ok( !lstrcmp( buf, join_res_fourth[i].one ),
2078             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_fourth[i].one, buf );
2079
2080         size = MAX_PATH;
2081         r = MsiRecordGetString( hrec, 2, buf, &size );
2082         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2083         ok( !lstrcmp( buf, join_res_fourth[i].two ),
2084             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_fourth[i].two, buf );
2085
2086         i++;
2087         MsiCloseHandle(hrec);
2088     }
2089
2090     ok( i == 1, "Expected 1 rows, got %d\n", i );
2091
2092     ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2093
2094     MsiViewClose(hview);
2095     MsiCloseHandle(hview);
2096
2097     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2098             "FROM `Component`, `FeatureComponents` "
2099             "WHERE `Component`.`Component` = 'zygomatic' "
2100             "AND `FeatureComponents`.`Component_` = 'maxilla' "
2101             "ORDER BY `Feature_`";
2102     r = MsiDatabaseOpenView(hdb, query, &hview);
2103     todo_wine
2104     {
2105         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2106     }
2107
2108     r = MsiViewExecute(hview, 0);
2109     todo_wine
2110     {
2111         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2112     }
2113
2114     i = 0;
2115     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2116     {
2117         count = MsiRecordGetFieldCount( hrec );
2118         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2119
2120         size = MAX_PATH;
2121         r = MsiRecordGetString( hrec, 1, buf, &size );
2122         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2123         ok( !lstrcmp( buf, join_res_fifth[i].one ),
2124             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_fifth[i].one, buf );
2125
2126         size = MAX_PATH;
2127         r = MsiRecordGetString( hrec, 2, buf, &size );
2128         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2129         ok( !lstrcmp( buf, join_res_fifth[i].two ),
2130             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_fifth[i].two, buf );
2131
2132         i++;
2133         MsiCloseHandle(hrec);
2134     }
2135
2136     todo_wine
2137     {
2138         ok( i == 1, "Expected 1 rows, got %d\n", i );
2139     }
2140
2141     todo_wine
2142     {
2143         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2144     }
2145
2146     MsiViewClose(hview);
2147     MsiCloseHandle(hview);
2148
2149     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2150             "FROM `Component`, `FeatureComponents` "
2151             "WHERE `Component` = 'zygomatic' "
2152             "ORDER BY `Feature_`";
2153     r = MsiDatabaseOpenView(hdb, query, &hview);
2154     todo_wine
2155     {
2156         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2157     }
2158
2159     r = MsiViewExecute(hview, 0);
2160     todo_wine
2161     {
2162         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2163     }
2164
2165     i = 0;
2166     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2167     {
2168         count = MsiRecordGetFieldCount( hrec );
2169         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2170
2171         size = MAX_PATH;
2172         r = MsiRecordGetString( hrec, 1, buf, &size );
2173         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2174         ok( !lstrcmp( buf, join_res_sixth[i].one ),
2175             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_sixth[i].one, buf );
2176
2177         size = MAX_PATH;
2178         r = MsiRecordGetString( hrec, 2, buf, &size );
2179         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2180         ok( !lstrcmp( buf, join_res_sixth[i].two ),
2181             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_sixth[i].two, buf );
2182
2183         i++;
2184         MsiCloseHandle(hrec);
2185     }
2186
2187     todo_wine
2188     {
2189         ok( i == 6, "Expected 6 rows, got %d\n", i );
2190     }
2191
2192     todo_wine
2193     {
2194         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2195     }
2196
2197     MsiViewClose(hview);
2198     MsiCloseHandle(hview);
2199
2200     query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
2201             "FROM `Component`, `FeatureComponents` "
2202             "WHERE `Component` = 'zygomatic' "
2203             "AND `Feature_` = 'nasalis' "
2204             "ORDER BY `Feature_`";
2205     r = MsiDatabaseOpenView(hdb, query, &hview);
2206     todo_wine
2207     {
2208         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2209     }
2210
2211     r = MsiViewExecute(hview, 0);
2212     todo_wine
2213     {
2214         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2215     }
2216
2217     i = 0;
2218     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2219     {
2220         count = MsiRecordGetFieldCount( hrec );
2221         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2222
2223         size = MAX_PATH;
2224         r = MsiRecordGetString( hrec, 1, buf, &size );
2225         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2226         ok( !lstrcmp( buf, join_res_seventh[i].one ),
2227             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_seventh[i].one, buf );
2228
2229         size = MAX_PATH;
2230         r = MsiRecordGetString( hrec, 2, buf, &size );
2231         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2232         ok( !lstrcmp( buf, join_res_seventh[i].two ),
2233             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_seventh[i].two, buf );
2234
2235         i++;
2236         MsiCloseHandle(hrec);
2237     }
2238
2239     todo_wine
2240     {
2241         ok( i == 3, "Expected 3 rows, got %d\n", i );
2242     }
2243
2244     todo_wine
2245     {
2246         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2247     }
2248
2249     MsiViewClose(hview);
2250     MsiCloseHandle(hview);
2251
2252     query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
2253             "FROM `StdDlls`, `Binary` ";
2254     r = MsiDatabaseOpenView(hdb, query, &hview);
2255     todo_wine
2256     {
2257         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2258     }
2259
2260     r = MsiViewExecute(hview, 0);
2261     todo_wine
2262     {
2263         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2264     }
2265
2266     i = 0;
2267     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2268     {
2269         count = MsiRecordGetFieldCount( hrec );
2270         ok( count == 2, "Expected 2 record fields, got %d\n", count );
2271
2272         size = MAX_PATH;
2273         r = MsiRecordGetString( hrec, 1, buf, &size );
2274         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2275         ok( !lstrcmp( buf, join_res_eighth[i].one ),
2276             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_eighth[i].one, buf );
2277
2278         size = MAX_PATH;
2279         r = MsiRecordGetString( hrec, 2, buf, &size );
2280         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2281         ok( !lstrcmp( buf, join_res_eighth[i].four ),
2282             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_eighth[i].four, buf );
2283
2284         i++;
2285         MsiCloseHandle(hrec);
2286     }
2287
2288     todo_wine
2289     {
2290         ok( i == 6, "Expected 6 rows, got %d\n", i );
2291         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2292     }
2293
2294     MsiViewClose(hview);
2295     MsiCloseHandle(hview);
2296
2297     query = "SELECT * FROM `StdDlls`, `Binary` ";
2298     r = MsiDatabaseOpenView(hdb, query, &hview);
2299     todo_wine
2300     {
2301         ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
2302     }
2303
2304     r = MsiViewExecute(hview, 0);
2305     todo_wine
2306     {
2307         ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
2308     }
2309
2310     i = 0;
2311     while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
2312     {
2313         count = MsiRecordGetFieldCount( hrec );
2314         ok( count == 4, "Expected 4 record fields, got %d\n", count );
2315
2316         size = MAX_PATH;
2317         r = MsiRecordGetString( hrec, 1, buf, &size );
2318         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2319         ok( !lstrcmp( buf, join_res_eighth[i].one ),
2320             "For (row %d, column 1) expected '%s', got %s\n", i, join_res_eighth[i].one, buf );
2321
2322         size = MAX_PATH;
2323         r = MsiRecordGetString( hrec, 2, buf, &size );
2324         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2325         ok( !lstrcmp( buf, join_res_eighth[i].two ),
2326             "For (row %d, column 2) expected '%s', got %s\n", i, join_res_eighth[i].two, buf );
2327
2328         size = MAX_PATH;
2329         r = MsiRecordGetString( hrec, 3, buf, &size );
2330         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2331         ok( !lstrcmp( buf, join_res_eighth[i].three ),
2332             "For (row %d, column 3) expected '%s', go %s\n", i, join_res_eighth[i].three, buf );
2333
2334         size = MAX_PATH;
2335         r = MsiRecordGetString( hrec, 4, buf, &size );
2336         ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
2337         ok( !lstrcmp( buf, join_res_eighth[i].four ),
2338             "For (row %d, column 4) expected '%s', got %s\n", i, join_res_eighth[i].four, buf );
2339
2340         i++;
2341         MsiCloseHandle(hrec);
2342     }
2343
2344     todo_wine
2345     {
2346         ok( i == 6, "Expected 6 rows, got %d\n", i );
2347         ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
2348     }
2349
2350     MsiViewClose(hview);
2351     MsiCloseHandle(hview);
2352
2353     MsiCloseHandle(hdb);
2354     DeleteFile(msifile);
2355 }
2356
2357 static void test_temporary_table(void)
2358 {
2359     MSICONDITION cond;
2360     MSIHANDLE hdb = 0, view = 0, rec;
2361     const char *query;
2362     UINT r;
2363     char buf[0x10];
2364     DWORD sz;
2365
2366     cond = MsiDatabaseIsTablePersistent(0, NULL);
2367     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2368
2369     hdb = create_db();
2370     ok( hdb, "failed to create db\n");
2371
2372     cond = MsiDatabaseIsTablePersistent(hdb, NULL);
2373     ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
2374
2375     todo_wine {
2376     cond = MsiDatabaseIsTablePersistent(hdb, "_Tables");
2377     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2378
2379     cond = MsiDatabaseIsTablePersistent(hdb, "_Columns");
2380     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2381
2382     cond = MsiDatabaseIsTablePersistent(hdb, "_Streams");
2383     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2384     }
2385
2386     query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
2387     r = run_query(hdb, 0, query);
2388     ok(r == ERROR_SUCCESS, "failed to add table\n");
2389
2390     cond = MsiDatabaseIsTablePersistent(hdb, "P");
2391     todo_wine ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2392
2393     query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
2394     r = run_query(hdb, 0, query);
2395     ok(r == ERROR_SUCCESS, "failed to add table\n");
2396
2397     todo_wine {
2398     cond = MsiDatabaseIsTablePersistent(hdb, "P");
2399     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2400     }
2401
2402     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
2403     r = run_query(hdb, 0, query);
2404     ok(r == ERROR_SUCCESS, "failed to add table\n");
2405
2406     cond = MsiDatabaseIsTablePersistent(hdb, "T");
2407     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
2408
2409     query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2410     r = run_query(hdb, 0, query);
2411     ok(r == ERROR_SUCCESS, "failed to add table\n");
2412
2413     todo_wine {
2414     cond = MsiDatabaseIsTablePersistent(hdb, "T2");
2415     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2416     }
2417
2418     query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
2419     r = run_query(hdb, 0, query);
2420     ok(r == ERROR_SUCCESS, "failed to add table\n");
2421
2422     todo_wine {
2423     cond = MsiDatabaseIsTablePersistent(hdb, "T3");
2424     ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
2425
2426     query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
2427     r = run_query(hdb, 0, query);
2428     ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
2429
2430     cond = MsiDatabaseIsTablePersistent(hdb, "T4");
2431     ok( cond == MSICONDITION_NONE, "wrong return condition\n");
2432     }
2433
2434     query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
2435     r = run_query(hdb, 0, query);
2436     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
2437
2438     query = "select * from `T`";
2439     r = MsiDatabaseOpenView(hdb, query, &view);
2440     ok(r == ERROR_SUCCESS, "failed to query table\n");
2441     r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
2442     ok(r == ERROR_SUCCESS, "failed to get column info\n");
2443
2444     sz = sizeof buf;
2445     r = MsiRecordGetString(rec, 1, buf, &sz);
2446     ok(r == ERROR_SUCCESS, "failed to get string\n");
2447     todo_wine ok( 0 == strcmp("G255", buf), "wrong column type\n");
2448
2449     sz = sizeof buf;
2450     r = MsiRecordGetString(rec, 2, buf, &sz);
2451     ok(r == ERROR_SUCCESS, "failed to get string\n");
2452     todo_wine ok( 0 == strcmp("j2", buf), "wrong column type\n");
2453
2454     MsiCloseHandle( rec );
2455     MsiCloseHandle( view );
2456
2457     /* query the table data */
2458     rec = 0;
2459     r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
2460     ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
2461     MsiCloseHandle( rec );
2462
2463     todo_wine {
2464     /* query the column data */
2465     rec = 0;
2466     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
2467     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2468     if (rec) MsiCloseHandle( rec );
2469
2470     r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
2471     ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
2472     if (rec) MsiCloseHandle( rec );
2473     }
2474
2475     MsiCloseHandle( hdb );
2476
2477     DeleteFile(msifile);
2478 }
2479
2480 static void test_alter(void)
2481 {
2482     MSICONDITION cond;
2483     MSIHANDLE hdb = 0;
2484     const char *query;
2485     UINT r;
2486
2487     hdb = create_db();
2488     ok( hdb, "failed to create db\n");
2489
2490     query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
2491     r = run_query(hdb, 0, query);
2492     ok(r == ERROR_SUCCESS, "failed to add table\n");
2493
2494     cond = MsiDatabaseIsTablePersistent(hdb, "T");
2495     ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
2496
2497     todo_wine {
2498     query = "ALTER TABLE `T` HOLD";
2499     r = run_query(hdb, 0, query);
2500     ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
2501
2502     query = "ALTER TABLE `T` FREE";
2503     r = run_query(hdb, 0, query);
2504     ok(r == ERROR_SUCCESS, "failed to free table\n");
2505
2506     query = "ALTER TABLE `T` FREE";
2507     r = run_query(hdb, 0, query);
2508     ok(r == ERROR_SUCCESS, "failed to free table\n");
2509     }
2510
2511     query = "ALTER TABLE `T` FREE";
2512     r = run_query(hdb, 0, query);
2513     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
2514
2515     query = "ALTER TABLE `T` HOLD";
2516     r = run_query(hdb, 0, query);
2517     ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
2518
2519     MsiCloseHandle( hdb );
2520
2521     DeleteFile(msifile);
2522 }
2523
2524 START_TEST(db)
2525 {
2526     test_msidatabase();
2527     test_msiinsert();
2528     test_msidecomposedesc();
2529     test_msibadqueries();
2530     test_viewmodify();
2531     test_viewgetcolumninfo();
2532     test_getcolinfo();
2533     test_msiexport();
2534     test_longstrings();
2535     test_streamtable();
2536     test_where();
2537     test_msiimport();
2538     test_markers();
2539     test_handle_limit();
2540     test_generate_transform();
2541     test_join();
2542     test_temporary_table();
2543     test_alter();
2544 }