db.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005 Mike McCormack for CodeWeavers
 *
 * A test program for MSI database files.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#define COBJMACROS
 
#include <stdio.h>
 
#include <windows.h>
#include <objidl.h>
#include <msi.h>
#include <msidefs.h>
#include <msiquery.h>
 
#include "wine/test.h"
#include "utils.h"
 
static const char *msifile = "winetest-db.msi";
static const char *msifile2 = "winetst2-db.msi";
static const char *mstfile = "winetst-db.mst";
static const WCHAR msifileW[] = L"winetest-db.msi";
static const WCHAR msifile2W[] = L"winetst2-db.msi";
 
static void WINAPIV check_record_(int line, MSIHANDLE rec, UINT count, ...)
{
    va_list args;
    UINT i;
 
    ok_(__FILE__, line)(count == MsiRecordGetFieldCount(rec),
            "expected %u fields, got %u\n", count, MsiRecordGetFieldCount(rec));
 
    va_start(args, count);
 
    for (i = 1; i <= count; ++i)
    {
        const char *expect = va_arg(args, const char *);
        char buffer[200] = "x";
        DWORD sz = sizeof(buffer);
        UINT r = MsiRecordGetStringA(rec, i, buffer, &sz);
        ok_(__FILE__, line)(r == ERROR_SUCCESS, "field %u: got unexpected error %u\n", i, r);
        ok_(__FILE__, line)(!strcmp(buffer, expect),
                "field %u: expected \"%s\", got \"%s\"\n", i, expect, buffer);
    }
 
    va_end(args);
}
#define check_record(rec, ...) check_record_(__LINE__, rec, __VA_ARGS__)
 
static void test_msidatabase(void)
{
    MSIHANDLE hdb = 0, hdb2 = 0;
    WCHAR path[MAX_PATH];
    DWORD len;
    UINT res;
 
    DeleteFileW(msifileW);
 
    res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb );
    ok( res == ERROR_OPEN_FAILED, "expected failure\n");
 
    res = MsiOpenDatabaseW( msifileW, (LPWSTR)0xff, &hdb );
    ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    /* create an empty database */
    res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to create database\n" );
 
    res = MsiDatabaseCommit( hdb );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
    res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    res = MsiDatabaseCommit( hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    res = MsiCloseHandle( hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    res = MsiCloseHandle( hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    ok( GetFileAttributesA( msifile2 ) == INVALID_FILE_ATTRIBUTES, "uncommitted database should not exist\n");
 
    res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    res = MsiDatabaseCommit( hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    res = MsiCloseHandle( hdb2 );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "committed database should exist\n");
 
    res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    res = MsiDatabaseCommit( hdb );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_DIRECT, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_TRANSACT, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
    ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    /* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
    res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    ok( GetFileAttributesA( msifile ) == INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to open database\n" );
 
    res = MsiDatabaseCommit( hdb );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
 
    res = MsiCloseHandle( hdb );
    ok( res == ERROR_SUCCESS , "Failed to close database\n" );
 
    res = GetCurrentDirectoryW(ARRAY_SIZE(path), path);
    ok ( res, "Got zero res.\n" );
    lstrcatW( path, L"\\");
    lstrcatW( path, msifileW);
    len = lstrlenW(path);
    path[len - 4] = 0;
 
    res = MsiOpenDatabaseW( path, MSIDBOPEN_READONLY, &hdb );
    ok( res != ERROR_SUCCESS , "Got unexpected res %u.\n", res );
 
    lstrcpyW( path, msifileW );
    path[lstrlenW(path) - 4] = 0;
 
    res = MsiOpenDatabaseW( path, MSIDBOPEN_READONLY, &hdb );
    ok( res != ERROR_SUCCESS , "Got unexpected res %u.\n", res );
 
    res = DeleteFileA( msifile2 );
    ok( res == TRUE, "Failed to delete database\n" );
 
    res = DeleteFileA( msifile );
    ok( res == TRUE, "Failed to delete database\n" );
}
 
static UINT do_query(MSIHANDLE hdb, const char *query, MSIHANDLE *phrec)
{
    MSIHANDLE hview = 0;
    UINT r, ret;
 
    if (phrec)
        *phrec = 0;
 
    /* open a select query */
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    if (r != ERROR_SUCCESS)
        return r;
    r = MsiViewExecute(hview, 0);
    if (r != ERROR_SUCCESS)
        return r;
    ret = MsiViewFetch(hview, phrec);
    r = MsiViewClose(hview);
    if (r != ERROR_SUCCESS)
        return r;
    r = MsiCloseHandle(hview);
    if (r != ERROR_SUCCESS)
        return r;
    return ret;
}
 
static UINT run_queryW( MSIHANDLE hdb, MSIHANDLE hrec, const WCHAR *query )
{
    MSIHANDLE hview = 0;
    UINT r;
 
    r = MsiDatabaseOpenViewW(hdb, query, &hview);
    if( r != ERROR_SUCCESS )
        return r;
 
    r = MsiViewExecute(hview, hrec);
    if( r == ERROR_SUCCESS )
        r = MsiViewClose(hview);
    MsiCloseHandle(hview);
    return r;
}
 
static UINT create_component_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
            "CREATE TABLE `Component` ( "
            "`Component` CHAR(72) NOT NULL, "
            "`ComponentId` CHAR(38), "
            "`Directory_` CHAR(72) NOT NULL, "
            "`Attributes` SHORT NOT NULL, "
            "`Condition` CHAR(255), "
            "`KeyPath` CHAR(72) "
            "PRIMARY KEY `Component`)" );
    ok(r == ERROR_SUCCESS, "Failed to create Component table: %u\n", r);
    return r;
}
 
static UINT create_custom_action_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
            "CREATE TABLE `CustomAction` ( "
            "`Action` CHAR(72) NOT NULL, "
            "`Type` SHORT NOT NULL, "
            "`Source` CHAR(72), "
            "`Target` CHAR(255) "
            "PRIMARY KEY `Action`)" );
    ok(r == ERROR_SUCCESS, "Failed to create CustomAction table: %u\n", r);
    return r;
}
 
static UINT create_directory_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
            "CREATE TABLE `Directory` ( "
            "`Directory` CHAR(255) NOT NULL, "
            "`Directory_Parent` CHAR(255), "
            "`DefaultDir` CHAR(255) NOT NULL "
            "PRIMARY KEY `Directory`)" );
    ok(r == ERROR_SUCCESS, "Failed to create Directory table: %u\n", r);
    return r;
}
 
static UINT create_feature_components_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
            "CREATE TABLE `FeatureComponents` ( "
            "`Feature_` CHAR(38) NOT NULL, "
            "`Component_` CHAR(72) NOT NULL "
            "PRIMARY KEY `Feature_`, `Component_` )" );
    ok(r == ERROR_SUCCESS, "Failed to create FeatureComponents table: %u\n", r);
    return r;
}
 
static UINT create_std_dlls_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
            "CREATE TABLE `StdDlls` ( "
            "`File` CHAR(255) NOT NULL, "
            "`Binary_` CHAR(72) NOT NULL "
            "PRIMARY KEY `File` )" );
    ok(r == ERROR_SUCCESS, "Failed to create StdDlls table: %u\n", r);
    return r;
}
 
static UINT create_binary_table( MSIHANDLE hdb )
{
    UINT r = run_query( hdb, 0,
           "CREATE TABLE `Binary` ( "
            "`Name` CHAR(72) NOT NULL, "
            "`Data` CHAR(72) NOT NULL "
            "PRIMARY KEY `Name` )" );
    ok(r == ERROR_SUCCESS, "Failed to create Binary table: %u\n", r);
    return r;
}
 
static inline UINT add_entry(const char *file, int line, const char *type, MSIHANDLE hdb, const char *values, const char *insert)
{
    char *query;
    UINT sz, r;
 
    sz = strlen(values) + strlen(insert) + 1;
    query = malloc(sz);
    sprintf(query, insert, values);
    r = run_query(hdb, 0, query);
    free(query);
    ok_(file, line)(r == ERROR_SUCCESS, "failed to insert into %s table: %u\n", type, r);
    return r;
}
 
#define add_component_entry(hdb, values) add_entry(__FILE__, __LINE__, "Component", hdb, values, \
               "INSERT INTO `Component`  " \
               "(`Component`, `ComponentId`, `Directory_`, " \
               "`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
 
#define add_custom_action_entry(hdb, values) add_entry(__FILE__, __LINE__, "CustomAction", hdb, values, \
               "INSERT INTO `CustomAction`  " \
               "(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
 
#define add_feature_components_entry(hdb, values) add_entry(__FILE__, __LINE__, "FeatureComponents", hdb, values, \
               "INSERT INTO `FeatureComponents` " \
               "(`Feature_`, `Component_`) VALUES( %s )")
 
#define add_std_dlls_entry(hdb, values) add_entry(__FILE__, __LINE__, "StdDlls", hdb, values, \
               "INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
 
#define add_binary_entry(hdb, values) add_entry(__FILE__, __LINE__, "Binary", hdb, values, \
               "INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
 
static void test_msiinsert(void)
{
    MSIHANDLE hdb = 0, hview = 0, hview2 = 0, hrec = 0;
    UINT r;
    const char *query;
    char buf[80];
    DWORD sz;
 
    DeleteFileA(msifile);
 
    /* just MsiOpenDatabase should not create a file */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    /* create a table */
    query = "CREATE TABLE `phone` ( "
            "`id` INT, `name` CHAR(32), `number` CHAR(32) "
            "PRIMARY KEY `id`)";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM phone WHERE number = '8675309'";
    r = MsiDatabaseOpenViewA(hdb, query, &hview2);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview2, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewFetch(hview2, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
 
    /* insert a value into it */
    query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
        "VALUES('1', 'Abe', '8675309')";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    r = MsiViewFetch(hview2, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch produced items\n");
    r = MsiViewExecute(hview2, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewFetch(hview2, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %u\n", r);
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
    r = MsiViewClose(hview2);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview2);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` = 1";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 
    /* check the record contains what we put in it */
    r = MsiRecordGetFieldCount(hrec);
    ok(r == 3, "record count wrong\n");
 
    r = MsiRecordIsNull(hrec, 0);
    ok(r == FALSE, "field 0 not null\n");
 
    r = MsiRecordGetInteger(hrec, 1);
    ok(r == 1, "field 1 contents wrong\n");
    sz = sizeof buf;
    r = MsiRecordGetStringA(hrec, 2, buf, &sz);
    ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
    ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
    sz = sizeof buf;
    r = MsiRecordGetStringA(hrec, 3, buf, &sz);
    ok(r == ERROR_SUCCESS, "field 3 content fetch failed\n");
    ok(!strcmp(buf,"8675309"), "field 3 content incorrect\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    /* open a select query */
    hrec = 100;
    query = "SELECT * FROM `phone` WHERE `id` >= 10";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
    ok(hrec == 0, "hrec should be null\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` < 0";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` <= 0";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` <> 1";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` > 10";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\n");
 
    /* now try a few bad INSERT xqueries */
    query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
        "VALUES(?, ?)";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "MsiDatabaseOpenView failed\n");
 
    /* construct a record to insert */
    hrec = MsiCreateRecord(4);
    r = MsiRecordSetInteger(hrec, 1, 2);
    ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
    r = MsiRecordSetStringA(hrec, 2, "Adam");
    ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
    r = MsiRecordSetStringA(hrec, 3, "96905305");
    ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 
    /* insert another value, using a record and wildcards */
    query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
        "VALUES(?, ?, ?)";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 
    if (r == ERROR_SUCCESS)
    {
        r = MsiViewExecute(hview, hrec);
        ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
        r = MsiViewClose(hview);
        ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
        r = MsiCloseHandle(hview);
        ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
    }
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    r = MsiViewFetch(0, NULL);
    ok(r == ERROR_INVALID_PARAMETER, "MsiViewFetch failed\n");
 
    r = MsiDatabaseCommit(hdb);
    ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
 
    r = MsiCloseHandle(hdb);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    r = DeleteFileA(msifile);
    ok(r == TRUE, "file didn't exist after commit\n");
}
 
static void test_msidecomposedesc(void)
{
    UINT (WINAPI *pMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
    char prod[MAX_FEATURE_CHARS+1], comp[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1];
    const char *desc;
    UINT r;
    DWORD len;
    HMODULE hmod;
 
    hmod = GetModuleHandleA("msi.dll");
    pMsiDecomposeDescriptorA = (void*)GetProcAddress(hmod, "MsiDecomposeDescriptorA");
    if (!pMsiDecomposeDescriptorA)
        return;
 
    /* test a valid feature descriptor */
    desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
    len = 0;
    prod[0] = feature[0] = comp[0] = 0;
    r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
    ok(r == ERROR_SUCCESS, "returned an error\n");
    ok(len == strlen(desc), "length was wrong\n");
    ok(strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}")==0, "product wrong\n");
    ok(strcmp(feature,"FollowTheWhiteRabbit")==0, "feature wrong\n");
    ok(strcmp(comp,"{A7CD68DB-EF74-49C8-FBB2-A7C463B2AC24}")==0,"component wrong\n");
 
    /* test an invalid feature descriptor with too many characters */
    desc = "']gAVn-}f(ZXfeAR6.ji"
           "ThisWillFailIfTheresMoreThanAGuidsChars>"
           "3w2x^IGfe?CxI5heAvk.";
    len = 0;
    r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
    ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
 
    /* test a feature descriptor with < instead of > */
    desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit<3w2x^IGfe?CxI5heAvk.";
    len = 0;
    prod[0] = feature[0] = 0;
    comp[0] = 0x55;
    r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
    ok(r == ERROR_SUCCESS, "returned an error\n");
    ok(len == 41, "got %lu\n", len);
    ok(!strcmp(prod,"{90110409-6000-11D3-8CFE-0150048383C9}"), "got '%s'\n", prod);
    ok(!strcmp(feature,"FollowTheWhiteRabbit"), "got '%s'\n", feature);
    ok(!comp[0], "got '%s'\n", comp);
 
    len = 0;
    prod[0] = feature[0] = 0;
    comp[0] = 0x55;
    r = pMsiDecomposeDescriptorA("yh1BVN)8A$!!!!!MKKSkAlwaysInstalledIntl_1033<", prod, feature, comp, &len);
    ok(r == ERROR_SUCCESS, "got %u\n", r);
    ok(len == 45, "got %lu\n", len);
    ok(!strcmp(prod, "{90150000-006E-0409-0000-0000000FF1CE}"), "got '%s'\n", prod);
    ok(!strcmp(feature, "AlwaysInstalledIntl_1033"), "got '%s'\n", feature);
    ok(!comp[0], "got '%s'\n", comp);
 
    /*
     * Test a valid feature descriptor with the
     * maximum number of characters and some trailing characters.
     */
    desc = "']gAVn-}f(ZXfeAR6.ji"
           "ThisWillWorkIfTheresLTEThanAGuidsChars>"
           "3w2x^IGfe?CxI5heAvk."
           "extra";
    len = 0;
    r = pMsiDecomposeDescriptorA(desc, prod, feature, comp, &len);
    ok(r == ERROR_SUCCESS, "returned wrong error\n");
    ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 
    len = 0;
    r = pMsiDecomposeDescriptorA(desc, prod, feature, NULL, &len);
    ok(r == ERROR_SUCCESS, "returned wrong error\n");
    ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 
    len = 0;
    r = pMsiDecomposeDescriptorA(desc, prod, NULL, NULL, &len);
    ok(r == ERROR_SUCCESS, "returned wrong error\n");
    ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 
    len = 0;
    r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, &len);
    ok(r == ERROR_SUCCESS, "returned wrong error\n");
    ok(len == (strlen(desc) - strlen("extra")), "length wrong\n");
 
    len = 0;
    r = pMsiDecomposeDescriptorA(NULL, NULL, NULL, NULL, &len);
    ok(r == ERROR_INVALID_PARAMETER, "returned wrong error\n");
    ok(len == 0, "length wrong\n");
 
    r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
    ok(r == ERROR_SUCCESS, "returned wrong error\n");
}
 
static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
{
    MSIHANDLE htab = 0;
    UINT res;
 
    res = MsiDatabaseOpenViewA( hdb, szQuery, &htab );
    if(res == ERROR_SUCCESS )
    {
        UINT r;
 
        r = MsiViewExecute( htab, hrec );
        if(r != ERROR_SUCCESS )
            res = r;
 
        r = MsiViewClose( htab );
        if(r != ERROR_SUCCESS )
            res = r;
 
        r = MsiCloseHandle( htab );
        if(r != ERROR_SUCCESS )
            res = r;
    }
    return res;
}
 
static UINT try_query( MSIHANDLE hdb, LPCSTR szQuery )
{
    return try_query_param( hdb, szQuery, 0 );
}
 
static UINT try_insert_query( MSIHANDLE hdb, LPCSTR szQuery )
{
    MSIHANDLE hrec = 0;
    UINT r;
 
    hrec = MsiCreateRecord( 1 );
    MsiRecordSetStringA( hrec, 1, "Hello");
 
    r = try_query_param( hdb, szQuery, hrec );
 
    MsiCloseHandle( hrec );
    return r;
}
 
static void test_msibadqueries(void)
{
    MSIHANDLE hdb = 0;
    UINT r;
 
    DeleteFileA(msifile);
 
    /* just MsiOpenDatabase should not create a file */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS , "Failed to commit database\n");
 
    r = MsiCloseHandle( hdb );
    ok(r == ERROR_SUCCESS , "Failed to close database\n");
 
    /* open it readonly */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb );
    ok(r == ERROR_SUCCESS , "Failed to open database r/o\n");
 
    /* add a table to it */
    r = try_query( hdb, "select * from _Tables");
    ok(r == ERROR_SUCCESS , "query 1 failed\n");
 
    r = MsiCloseHandle( hdb );
    ok(r == ERROR_SUCCESS , "Failed to close database r/o\n");
 
    /* open it read/write */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
    ok(r == ERROR_SUCCESS , "Failed to open database r/w\n");
 
    /* a bunch of test queries that fail with the native MSI */
 
    r = try_query( hdb, "CREATE TABLE");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2a return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a`");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2b return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` ()");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2c return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2d return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) )");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2e return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2f return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2g return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2h return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2i return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY 'b')");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2j return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2k return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b')");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2l return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHA(72) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2m return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(-1) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2n return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(720) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2o return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`` CHAR(72) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "invalid query 2p return code\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_SUCCESS , "valid query 2z failed\n");
 
    r = try_query( hdb, "CREATE TABLE `a` (`b` CHAR(72) NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_BAD_QUERY_SYNTAX , "created same table again\n");
 
    r = try_query( hdb, "CREATE TABLE `aa` (`b` CHAR(72) NOT NULL, `c` "
          "CHAR(72), `d` CHAR(255) NOT NULL LOCALIZABLE PRIMARY KEY `b`)");
    ok(r == ERROR_SUCCESS , "query 4 failed\n");
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 
    r = try_query( hdb, "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL "
                          "PRIMARY KEY `foo`)");
    ok(r == ERROR_SUCCESS , "query 4 failed\n");
 
    r = try_insert_query( hdb, "insert into a  ( `b` ) VALUES ( ? )");
    ok(r == ERROR_SUCCESS , "failed to insert record in db\n");
 
    r = MsiDatabaseCommit( hdb );
    ok(r == ERROR_SUCCESS , "Failed to commit database after write\n");
 
    r = try_query( hdb, "CREATE TABLE `boo` (`foo` CHAR(72) NOT NULL "
                          "PRIMARY KEY `ba`)");
    ok(r != ERROR_SUCCESS , "query 5 succeeded\n");
 
    r = try_query( hdb,"CREATE TABLE `bee` (`foo` CHAR(72) NOT NULL )");
    ok(r != ERROR_SUCCESS , "query 6 succeeded\n");
 
    r = try_query( hdb, "CREATE TABLE `temp` (`t` CHAR(72) NOT NULL "
                          "PRIMARY KEY `t`)");
    ok(r == ERROR_SUCCESS , "query 7 failed\n");
 
    r = try_query( hdb, "CREATE TABLE `c` (`b` CHAR NOT NULL PRIMARY KEY `b`)");
    ok(r == ERROR_SUCCESS , "query 8 failed\n");
 
    r = try_query( hdb, "select * from c");
    ok(r == ERROR_SUCCESS , "query failed\n");
 
    r = try_query( hdb, "select * from c where b = 'x");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select * from c where b = 'x'");
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    r = try_query( hdb, "select * from 'c'");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select * from ''");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select * from c where b = x");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select * from c where b = \"x\"");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select * from c where b = 'x'");
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    r = try_query( hdb, "select * from c where b = '\"x'");
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    if (0)  /* FIXME: this query causes trouble with other tests */
    {
        r = try_query( hdb, "select * from c where b = '\\\'x'");
        ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
    }
 
    r = try_query( hdb, "select * from 'c'");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "query failed\n");
 
    r = try_query( hdb, "select `c`.`b` from `c` order by `c`.`order`");
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.b` from `c`");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.`b from `c`");
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.b from `c`");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c.`b` from `c`");
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 
    r = try_query( hdb, "select c`.`b` from `c`");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "select c.`b` from `c`");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.`b` from c`");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.`b` from `c");
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
 
    r = try_query( hdb, "select `c`.`b` from c");
    ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
 
    r = try_query( hdb, "CREATE TABLE `\5a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "SELECT * FROM \5a" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "CREATE TABLE `a\5` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "SELECT * FROM a\5" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "CREATE TABLE `-a` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "SELECT * FROM -a" );
    todo_wine ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "CREATE TABLE `a-` (`b` CHAR NOT NULL PRIMARY KEY `b`)" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = try_query( hdb, "SELECT * FROM a-" );
    ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
 
    r = MsiCloseHandle( hdb );
    ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
 
    r = DeleteFileA( msifile );
    ok(r == TRUE, "file didn't exist after commit\n");
}
 
static void test_viewmodify(void)
{
    MSIHANDLE hdb = 0, hview = 0, hrec = 0;
    UINT r;
    MSIDBERROR err;
    const char *query;
    char buffer[0x100];
    DWORD sz;
 
    DeleteFileA(msifile);
 
    /* just MsiOpenDatabase should not create a file */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    query = "CREATE TABLE `phone` ( "
            "`id` INT, `name` CHAR(32), `number` CHAR(32) "
            "PRIMARY KEY `id`)";
    r = run_query( hdb, 0, query );
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    query = "CREATE TABLE `_Validation` ( "
            "`Table` CHAR(32) NOT NULL, `Column` CHAR(32) NOT NULL, "
            "`Nullable` CHAR(4) NOT NULL, `MinValue` INT, `MaxValue` INT, "
            "`KeyTable` CHAR(255), `KeyColumn` SHORT, `Category` CHAR(32), "
            "`Set` CHAR(255), `Description` CHAR(255) PRIMARY KEY `Table`, `Column`)";
    r = run_query( hdb, 0, query );
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    query = "INSERT INTO `_Validation` ( `Table`, `Column`, `Nullable` ) "
            "VALUES('phone', 'id', 'N')";
    r = run_query( hdb, 0, query );
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    query = "SELECT * FROM `phone`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 
    /* check what the error function reports without doing anything */
    sz = sizeof(buffer);
    strcpy(buffer, "x");
    err = MsiViewGetErrorA( hview, buffer, &sz );
    ok(err == MSIDBERROR_NOERROR, "got %d\n", err);
    ok(!buffer[0], "got \"%s\"\n", buffer);
    ok(sz == 0, "got size %lu\n", sz);
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    /* try some invalid records */
    r = MsiViewModify(hview, MSIMODIFY_INSERT, 0 );
    ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
    r = MsiViewModify(hview, -1, 0 );
    ok(r == ERROR_INVALID_HANDLE, "MsiViewModify failed\n");
 
    /* try an small record */
    hrec = MsiCreateRecord(1);
    r = MsiViewModify(hview, -1, hrec );
    ok(r == ERROR_INVALID_DATA, "MsiViewModify failed\n");
 
    sz = sizeof(buffer);
    strcpy(buffer, "x");
    err = MsiViewGetErrorA( hview, buffer, &sz );
    ok(err == MSIDBERROR_NOERROR, "got %d\n", err);
    ok(!buffer[0], "got \"%s\"\n", buffer);
    ok(sz == 0, "got size %lu\n", sz);
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    /* insert a valid record */
    hrec = MsiCreateRecord(3);
 
    r = MsiRecordSetInteger(hrec, 1, 1);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "bob");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
    r = MsiRecordSetStringA(hrec, 3, "7654321");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
    ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 
    /* validate it */
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiViewModify(hview, MSIMODIFY_VALIDATE_NEW, hrec );
    ok(r == ERROR_INVALID_DATA, "MsiViewModify failed %u\n", r);
 
    sz = sizeof(buffer);
    strcpy(buffer, "x");
    err = MsiViewGetErrorA( hview, buffer, &sz );
    ok(err == MSIDBERROR_DUPLICATEKEY, "got %d\n", err);
    ok(!strcmp(buffer, "id"), "got \"%s\"\n", buffer);
    ok(sz == 2, "got size %lu\n", sz);
 
    /* insert the same thing again */
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    /* should fail ... */
    r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
    ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 
    /* try to merge the same record */
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
    ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    /* try merging a new record */
    hrec = MsiCreateRecord(3);
 
    r = MsiRecordSetInteger(hrec, 1, 10);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "pepe");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
    r = MsiRecordSetStringA(hrec, 3, "7654321");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewModify(hview, MSIMODIFY_MERGE, hrec );
    ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM `phone`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
    check_record(hrec, 3, "1", "bob", "7654321");
 
    /* update the view, non-primary key */
    r = MsiRecordSetStringA(hrec, 3, "3141592");
    ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 
    /* do it again */
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
 
    /* update the view, primary key */
    r = MsiRecordSetInteger(hrec, 1, 5);
    ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM `phone`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
    check_record(hrec, 3, "1", "bob", "3141592");
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    /* use a record that doesn't come from a view fetch */
    hrec = MsiCreateRecord(3);
    ok(hrec != 0, "MsiCreateRecord failed\n");
 
    r = MsiRecordSetInteger(hrec, 1, 3);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "jane");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
    r = MsiRecordSetStringA(hrec, 3, "112358");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    /* use a record that doesn't come from a view fetch, primary key matches */
    hrec = MsiCreateRecord(3);
    ok(hrec != 0, "MsiCreateRecord failed\n");
 
    r = MsiRecordSetInteger(hrec, 1, 1);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "jane");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
    r = MsiRecordSetStringA(hrec, 3, "112358");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
 
    hrec = MsiCreateRecord(3);
 
    r = MsiRecordSetInteger(hrec, 1, 2);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "nick");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
    r = MsiRecordSetStringA(hrec, 3, "141421");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec );
    ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "SELECT * FROM `phone` WHERE `id` = 1";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 
    /* change the id to match the second row */
    r = MsiRecordSetInteger(hrec, 1, 2);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "jerry");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    /* broader search */
    query = "SELECT * FROM `phone` ORDER BY `id`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 
    /* change the id to match the second row */
    r = MsiRecordSetInteger(hrec, 1, 2);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
    r = MsiRecordSetStringA(hrec, 2, "jerry");
    ok(r == ERROR_SUCCESS, "failed to set string\n");
 
    r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
    ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
 
    r = MsiCloseHandle(hrec);
    ok(r == ERROR_SUCCESS, "failed to close record\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    r = MsiCloseHandle( hdb );
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
}
 
static MSIHANDLE create_db(void)
{
    MSIHANDLE hdb = 0;
    UINT res;
 
    DeleteFileW(msifileW);
 
    /* create an empty database */
    res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to create database\n" );
    if( res != ERROR_SUCCESS )
        return hdb;
 
    res = MsiDatabaseCommit( hdb );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    return hdb;
}
 
static void test_getcolinfo(void)
{
    MSIHANDLE hdb, hview = 0, rec = 0;
    UINT r;
 
    /* create an empty db */
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    /* tables should be present */
    r = MsiDatabaseOpenViewA(hdb, "select Name from _Tables", &hview);
    ok( r == ERROR_SUCCESS, "failed to open query\n");
 
    r = MsiViewExecute(hview, 0);
    ok( r == ERROR_SUCCESS, "failed to execute query\n");
 
    /* check that NAMES works */
    rec = 0;
    r = MsiViewGetColumnInfo( hview, MSICOLINFO_NAMES, &rec );
    ok( r == ERROR_SUCCESS, "failed to get names\n");
    check_record(rec, 1, "Name");
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 
    /* check that TYPES works */
    rec = 0;
    r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, &rec );
    ok( r == ERROR_SUCCESS, "failed to get names\n");
    check_record(rec, 1, "s64");
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS, "failed to close record handle\n");
 
    /* check that invalid values fail */
    rec = 0;
    r = MsiViewGetColumnInfo( hview, 100, &rec );
    ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
    ok( rec == 0, "returned a record\n");
 
    r = MsiViewGetColumnInfo( hview, MSICOLINFO_TYPES, NULL );
    ok( r == ERROR_INVALID_PARAMETER, "wrong error code\n");
 
    r = MsiViewGetColumnInfo( 0, MSICOLINFO_TYPES, &rec );
    ok( r == ERROR_INVALID_HANDLE, "wrong error code\n");
 
    r = MsiViewClose(hview);
    ok( r == ERROR_SUCCESS, "failed to close view\n");
    r = MsiCloseHandle(hview);
    ok( r == ERROR_SUCCESS, "failed to close view handle\n");
    r = MsiCloseHandle(hdb);
    ok( r == ERROR_SUCCESS, "failed to close database\n");
}
 
static MSIHANDLE get_column_info(MSIHANDLE hdb, const char *query, MSICOLINFO type)
{
    MSIHANDLE hview = 0, rec = 0;
    UINT r;
 
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    if( r != ERROR_SUCCESS )
        return r;
 
    r = MsiViewExecute(hview, 0);
    if( r == ERROR_SUCCESS )
    {
        MsiViewGetColumnInfo( hview, type, &rec );
    }
    MsiViewClose(hview);
    MsiCloseHandle(hview);
    return rec;
}
 
static UINT get_columns_table_type(MSIHANDLE hdb, const char *table, UINT field)
{
    MSIHANDLE hview = 0, rec = 0;
    UINT r, type = 0;
    char query[0x100];
 
    sprintf(query, "select * from `_Columns` where  `Table` = '%s'", table );
 
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    if( r != ERROR_SUCCESS )
        return r;
 
    r = MsiViewExecute(hview, 0);
    if( r == ERROR_SUCCESS )
    {
        while (1)
        {
            r = MsiViewFetch( hview, &rec );
            if( r != ERROR_SUCCESS)
                break;
            r = MsiRecordGetInteger( rec, 2 );
            if (r == field)
                type = MsiRecordGetInteger( rec, 4 );
            MsiCloseHandle( rec );
        }
    }
    MsiViewClose(hview);
    MsiCloseHandle(hview);
    return type;
}
 
static void test_viewgetcolumninfo(void)
{
    MSIHANDLE hdb = 0, rec;
    UINT r;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    r = run_query( hdb, 0,
            "CREATE TABLE `Properties` "
            "( `Property` CHAR(255), "
            "  `Value` CHAR(1), "
            "  `Intvalue` INT, "
            "  `Integervalue` INTEGER, "
            "  `Shortvalue` SHORT, "
            "  `Longvalue` LONG, "
            "  `Longcharvalue` LONGCHAR, "
            "  `Charvalue` CHAR, "
            "  `Localizablevalue` CHAR LOCALIZABLE "
            "  PRIMARY KEY `Property`)" );
    ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 
    /* check the column types */
    rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_TYPES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 9, "S255", "S1", "I2", "I2", "I2", "I4", "S0", "S0", "L0");
    MsiCloseHandle( rec );
 
    /* check the type in _Columns */
    ok( 0x3dff == get_columns_table_type(hdb, "Properties", 1 ), "_columns table wrong\n");
    ok( 0x1d01 == get_columns_table_type(hdb, "Properties", 2 ), "_columns table wrong\n");
    ok( 0x1502 == get_columns_table_type(hdb, "Properties", 3 ), "_columns table wrong\n");
    ok( 0x1502 == get_columns_table_type(hdb, "Properties", 4 ), "_columns table wrong\n");
    ok( 0x1502 == get_columns_table_type(hdb, "Properties", 5 ), "_columns table wrong\n");
    ok( 0x1104 == get_columns_table_type(hdb, "Properties", 6 ), "_columns table wrong\n");
    ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 7 ), "_columns table wrong\n");
    ok( 0x1d00 == get_columns_table_type(hdb, "Properties", 8 ), "_columns table wrong\n");
    ok( 0x1f00 == get_columns_table_type(hdb, "Properties", 9 ), "_columns table wrong\n");
 
    /* now try the names */
    rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 9, "Property", "Value", "Intvalue", "Integervalue", "Shortvalue",
            "Longvalue", "Longcharvalue", "Charvalue", "Localizablevalue");
    MsiCloseHandle( rec );
 
    r = run_query( hdb, 0,
            "CREATE TABLE `Binary` "
            "( `Name` CHAR(255), `Data` OBJECT  PRIMARY KEY `Name`)" );
    ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 
    /* check the column types */
    rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_TYPES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "S255", "V0");
    MsiCloseHandle( rec );
 
    /* check the type in _Columns */
    ok( 0x3dff == get_columns_table_type(hdb, "Binary", 1 ), "_columns table wrong\n");
    ok( 0x1900 == get_columns_table_type(hdb, "Binary", 2 ), "_columns table wrong\n");
 
    /* now try the names */
    rec = get_column_info( hdb, "select * from `Binary`", MSICOLINFO_NAMES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "Name", "Data");
    MsiCloseHandle( rec );
 
    r = run_query( hdb, 0,
            "CREATE TABLE `UIText` "
            "( `Key` CHAR(72) NOT NULL, `Text` CHAR(255) LOCALIZABLE PRIMARY KEY `Key`)" );
    ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 
    ok( 0x2d48 == get_columns_table_type(hdb, "UIText", 1 ), "_columns table wrong\n");
    ok( 0x1fff == get_columns_table_type(hdb, "UIText", 2 ), "_columns table wrong\n");
 
    rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_NAMES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "Key", "Text");
    MsiCloseHandle( rec );
 
    rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "s72", "L255");
    MsiCloseHandle( rec );
 
    MsiCloseHandle( hdb );
}
 
static void test_msiexport(void)
{
    MSIHANDLE hdb = 0, hview = 0;
    UINT r;
    const char *query;
    char path[MAX_PATH];
    const char file[] = "phone.txt";
    HANDLE handle;
    char buffer[0x100];
    DWORD length;
    const char expected[] =
        "id\tname\tnumber\r\n"
        "I2\tS32\tS32\r\n"
        "phone\tid\r\n"
        "1\tAbe\t8675309\r\n";
 
    DeleteFileW(msifileW);
 
    /* just MsiOpenDatabase should not create a file */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    /* create a table */
    query = "CREATE TABLE `phone` ( "
            "`id` INT, `name` CHAR(32), `number` CHAR(32) "
            "PRIMARY KEY `id`)";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    /* insert a value into it */
    query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
        "VALUES('1', 'Abe', '8675309')";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    GetCurrentDirectoryA(MAX_PATH, path);
 
    r = MsiDatabaseExportA(hdb, "phone", path, file);
    ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
 
    MsiCloseHandle(hdb);
 
    lstrcatA(path, "\\");
    lstrcatA(path, file);
 
    /* check the data that was written */
    length = 0;
    memset(buffer, 0, sizeof buffer);
    handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
    if (handle != INVALID_HANDLE_VALUE)
    {
        ReadFile(handle, buffer, sizeof buffer, &length, NULL);
        CloseHandle(handle);
        DeleteFileA(path);
    }
    else
        ok(0, "failed to open file %s\n", path);
 
    ok( length == strlen(expected), "length of data wrong\n");
    ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
    DeleteFileA(msifile);
}
 
static void test_longstrings(void)
{
    const char insert_query[] =
        "INSERT INTO `strings` ( `id`, `val` ) VALUES('1', 'Z')";
    char *str;
    MSIHANDLE hdb = 0, hview = 0, hrec = 0;
    DWORD len;
    UINT r;
    const DWORD STRING_LENGTH = 0x10005;
 
    DeleteFileW(msifileW);
    /* just MsiOpenDatabase should not create a file */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    /* create a table */
    r = try_query( hdb,
        "CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
    ok(r == ERROR_SUCCESS, "query failed\n");
 
    /* try to insert a very long string */
    str = malloc(STRING_LENGTH + sizeof insert_query);
    len = strchr(insert_query, 'Z') - insert_query;
    strcpy(str, insert_query);
    memset(str+len, 'Z', STRING_LENGTH);
    strcpy(str+len+STRING_LENGTH, insert_query+len+1);
    r = try_query( hdb, str );
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    free(str);
 
    r = MsiDatabaseCommit(hdb);
    ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
    MsiCloseHandle(hdb);
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
    ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
 
    r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
 
    MsiViewClose(hview);
    MsiCloseHandle(hview);
 
    r = MsiRecordGetStringA(hrec, 2, NULL, &len);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
    ok(len == STRING_LENGTH, "string length wrong\n");
 
    MsiCloseHandle(hrec);
    MsiCloseHandle(hdb);
    DeleteFileA(msifile);
}
 
static void test_streamtable(void)
{
    MSIHANDLE hdb = 0, rec, view, hsi;
    char file[MAX_PATH];
    char buf[MAX_PATH];
    DWORD size;
    UINT r;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    r = run_query( hdb, 0,
            "CREATE TABLE `Properties` "
            "( `Property` CHAR(255), `Value` CHAR(1)  PRIMARY KEY `Property`)" );
    ok( r == ERROR_SUCCESS , "Failed to create table\n" );
 
    r = run_query( hdb, 0,
            "INSERT INTO `Properties` "
            "( `Value`, `Property` ) VALUES ( 'Prop', 'value' )" );
    ok( r == ERROR_SUCCESS, "Failed to add to table\n" );
 
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    MsiCloseHandle( hdb );
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
    ok( r == ERROR_SUCCESS , "Failed to open database\n" );
 
    /* check the column types */
    rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "s62", "V0");
    MsiCloseHandle( rec );
 
    /* now try the names */
    rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_NAMES );
    ok( rec, "failed to get column info record\n" );
    check_record(rec, 2, "Name", "Data");
    MsiCloseHandle( rec );
 
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
 
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
 
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_NO_MORE_ITEMS, "Unexpected result: %u\n", r );
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* create a summary information stream */
    r = MsiGetSummaryInformationA( hdb, NULL, 1, &hsi );
    ok( r == ERROR_SUCCESS, "Failed to get summary information handle: %u\n", r );
 
    r = MsiSummaryInfoSetPropertyA( hsi, PID_SECURITY, VT_I4, 2, NULL, NULL );
    ok( r == ERROR_SUCCESS, "Failed to set property: %u\n", r );
 
    r = MsiSummaryInfoPersist( hsi );
    ok( r == ERROR_SUCCESS, "Failed to save summary information: %u\n", r );
 
    MsiCloseHandle( hsi );
 
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT * FROM `_Streams` WHERE `Name` = '\5SummaryInformation'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %u\n", r );
 
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %u\n", r );
 
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Unexpected result: %u\n", r );
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* insert a file into the _Streams table */
    create_file( "test.txt", 0 );
 
    rec = MsiCreateRecord( 2 );
    MsiRecordSetStringA( rec, 1, "data" );
 
    r = MsiRecordSetStreamA( rec, 2, "test.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
 
    DeleteFileA("test.txt");
 
    r = MsiDatabaseOpenViewA( hdb,
            "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, rec );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* insert another one */
    create_file( "test1.txt", 0 );
 
    rec = MsiCreateRecord( 2 );
    MsiRecordSetStringA( rec, 1, "data1" );
 
    r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
 
    DeleteFileA("test1.txt");
 
    r = MsiDatabaseOpenViewA( hdb,
            "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, rec );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* try again */
    create_file( "test1.txt", 0 );
 
    rec = MsiCreateRecord( 2 );
    MsiRecordSetStringA( rec, 1, "data1" );
 
    r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
 
    DeleteFileA( "test1.txt" );
 
    r = MsiDatabaseOpenViewA( hdb,
            "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r );
 
    r = MsiViewExecute( view, rec );
    ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
 
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
 
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    ok( !lstrcmpA(buf, "test.txt"), "Expected 'test.txt', got %s\n", buf);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
 
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    ok( !lstrcmpA(buf, "test1.txt"), "Expected 'test1.txt', got %s\n", buf);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* perform an update */
    create_file( "test2.txt", 0 );
    rec = MsiCreateRecord( 1 );
 
    r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
 
    DeleteFileA("test2.txt");
 
    r = MsiDatabaseOpenViewA( hdb,
            "UPDATE `_Streams` SET `Data` = ? WHERE `Name` = 'data1'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, rec );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data1'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
 
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
 
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Failed to fetch record: %d\n", r);
 
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
 
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    ok( !lstrcmpA(buf, "test2.txt"), "Expected 'test2.txt', got %s\n", buf);
 
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
    MsiCloseHandle( hdb );
    DeleteFileA(msifile);
 
    /* insert a file into the _Streams table */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
    ok(r == ERROR_SUCCESS, "Failed to create database\n");
    ok( hdb, "failed to create db\n");
    create_file( "test.txt", 0 );
    rec = MsiCreateRecord( 2 );
    MsiRecordSetStringA( rec, 1, "data" );
    r = MsiRecordSetStreamA( rec, 2, "test.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
    DeleteFileA("test.txt");
    r = MsiDatabaseOpenViewA( hdb,
            "INSERT INTO `_Streams` ( `Name`, `Data` ) VALUES ( ?, ? )", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
    r = MsiViewExecute( view, rec );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
    MsiCloseHandle( rec );
    MsiViewClose( view );
    MsiCloseHandle( view );
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    /* open a handle to the "data" stream */
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiViewClose( view );
    MsiCloseHandle( view );
    /* read the stream while it still exists (normal case) */
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    ok( !lstrcmpA(buf, "test.txt"), "Expected 'test.txt', got '%s' (%lu)\n", buf, size);
    MsiCloseHandle( rec );
 
    /* open a handle to the "data" stream (and keep it open during removal) */
    r = MsiDatabaseOpenViewA( hdb,
            "SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
    r = MsiViewFetch( view, &rec );
    ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* remove the stream */
    r = MsiDatabaseOpenViewA( hdb,
            "DELETE FROM `_Streams` WHERE `Name` = 'data'", &view );
    ok( r == ERROR_SUCCESS, "Failed to open database view: %d\n", r);
    r = MsiViewExecute( view, 0 );
    ok( r == ERROR_SUCCESS, "Failed to execute view: %d\n", r);
    MsiViewClose( view );
    MsiCloseHandle( view );
 
    /* attempt to read the stream that no longer exists (abnormal case) */
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    todo_wine ok( size == 0, "Expected empty buffer, got %lu bytes\n", size);
    MsiCloseHandle( rec );
 
    MsiCloseHandle( hdb );
    DeleteFileA(msifile);
}
 
static void test_binary(void)
{
    MSIHANDLE hdb = 0, rec;
    char file[MAX_PATH];
    char buf[MAX_PATH];
    DWORD size;
    LPCSTR query;
    UINT r;
 
    /* insert a file into the Binary table */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( r == ERROR_SUCCESS , "Failed to open database\n" );
 
    query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
    r = run_query( hdb, 0, query );
    ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
 
    create_file( "test.txt", 0 );
    rec = MsiCreateRecord( 1 );
    r = MsiRecordSetStreamA( rec, 1, "test.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
    DeleteFileA( "test.txt" );
 
    /* try a name that exceeds maximum OLE stream name length */
    query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'encryption.dll.CB4E6205_F99A_4C51_ADD4_184506EFAB87', 10000, ? )";
    r = run_query( hdb, rec, query );
    ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
 
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
 
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_FUNCTION_FAILED , "got %u\n", r );
 
    r = MsiCloseHandle( hdb );
    ok( r == ERROR_SUCCESS , "Failed to close database\n" );
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
    ok( r == ERROR_SUCCESS , "Failed to open database\n" );
 
    query = "CREATE TABLE `Binary` ( `Name` CHAR(72) NOT NULL, `ID` INT NOT NULL, `Data` OBJECT  PRIMARY KEY `Name`, `ID`)";
    r = run_query( hdb, 0, query );
    ok( r == ERROR_SUCCESS, "Cannot create Binary table: %d\n", r );
 
    create_file( "test.txt", 0 );
    rec = MsiCreateRecord( 1 );
    r = MsiRecordSetStreamA( rec, 1, "test.txt" );
    ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r );
    DeleteFileA( "test.txt" );
 
    query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
    r = run_query( hdb, rec, query );
    ok( r == ERROR_SUCCESS, "Insert into Binary table failed: %d\n", r );
 
    query = "INSERT INTO `Binary` ( `Name`, `ID`, `Data` ) VALUES ( 'filename1', 1, ? )";
    r = run_query( hdb, rec, query );
    ok( r == ERROR_FUNCTION_FAILED, "got %u\n", r );
 
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
 
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    r = MsiCloseHandle( hdb );
    ok( r == ERROR_SUCCESS , "Failed to close database\n" );
 
    /* read file from the Stream table */
    r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
    ok( r == ERROR_SUCCESS , "Failed to open database\n" );
 
    query = "SELECT * FROM `_Streams`";
    r = do_query( hdb, query, &rec );
    ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
 
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
    ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
 
    size = MAX_PATH;
    memset( buf, 0, MAX_PATH );
    r = MsiRecordReadStream( rec, 2, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
    ok( !lstrcmpA(buf, "test.txt"), "Expected 'test.txt', got %s\n", buf );
 
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
 
    /* read file from the Binary table */
    query = "SELECT * FROM `Binary`";
    r = do_query( hdb, query, &rec );
    ok( r == ERROR_SUCCESS, "SELECT query failed: %d\n", r );
 
    size = MAX_PATH;
    r = MsiRecordGetStringA( rec, 1, file, &size );
    ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
    ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
 
    size = MAX_PATH;
    memset( buf, 0, MAX_PATH );
    r = MsiRecordReadStream( rec, 3, buf, &size );
    ok( r == ERROR_SUCCESS, "Failed to get stream: %d\n", r );
    ok( !lstrcmpA(buf, "test.txt"), "Expected 'test.txt', got %s\n", buf );
 
    r = MsiCloseHandle( rec );
    ok( r == ERROR_SUCCESS , "Failed to close record handle\n" );
 
    r = MsiCloseHandle( hdb );
    ok( r == ERROR_SUCCESS , "Failed to close database\n" );
 
    DeleteFileA( msifile );
}
 
static void test_where_not_in_selected(void)
{
    MSIHANDLE hdb = 0, rec, view;
    LPCSTR query;
    UINT r;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    r = run_query(hdb, 0,
            "CREATE TABLE `IESTable` ("
            "`Action` CHAR(64), "
            "`Condition` CHAR(64), "
            "`Sequence` LONG PRIMARY KEY `Sequence`)");
    ok( r == S_OK, "Cannot create IESTable table: %d\n", r);
 
    r = run_query(hdb, 0,
            "CREATE TABLE `CATable` ("
            "`Action` CHAR(64), "
            "`Type` LONG PRIMARY KEY `Type`)");
    ok( r == S_OK, "Cannot create CATable table: %d\n", r);
 
    r = run_query(hdb, 0, "INSERT INTO `IESTable` "
            "( `Action`, `Condition`, `Sequence`) "
            "VALUES ( 'clean', 'cond4', 4)");
    ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `IESTable` "
            "( `Action`, `Condition`, `Sequence`) "
            "VALUES ( 'depends', 'cond1', 1)");
    ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `IESTable` "
            "( `Action`, `Condition`, `Sequence`) "
            "VALUES ( 'build', 'cond2', 2)");
    ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `IESTable` "
            "( `Action`, `Condition`, `Sequence`) "
            "VALUES ( 'build2', 'cond6', 6)");
    ok( r == S_OK, "cannot add entry to IESTable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `IESTable` "
            "( `Action`, `Condition`, `Sequence`) "
            "VALUES ( 'build', 'cond3', 3)");
    ok(r == S_OK, "cannot add entry to IESTable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `CATable` "
            "( `Action`, `Type` ) "
            "VALUES ( 'build', 32)");
    ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `CATable` "
            "( `Action`, `Type` ) "
            "VALUES ( 'depends', 64)");
    ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `CATable` "
            "( `Action`, `Type` ) "
            "VALUES ( 'clean', 63)");
    ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
 
    r = run_query(hdb, 0, "INSERT INTO `CATable` "
            "( `Action`, `Type` ) "
            "VALUES ( 'build2', 34)");
    ok(r == S_OK, "cannot add entry to CATable table:%d\n", r );
    query = "Select IESTable.Condition from CATable, IESTable where "
            "CATable.Action = IESTable.Action and CATable.Type = 32";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
 
    r = MsiViewExecute(view, 0);
    ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
 
    r = MsiViewFetch(view, &rec);
    ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
    check_record(rec, 1, "cond2");
    MsiCloseHandle( rec );
 
    r = MsiViewFetch(view, &rec);
    ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
    check_record(rec, 1, "cond3");
    MsiCloseHandle( rec );
 
    MsiViewClose(view);
    MsiCloseHandle(view);
 
    MsiCloseHandle( hdb );
    DeleteFileA(msifile);
}
 
 
static void test_where(void)
{
    MSIHANDLE hdb = 0, rec, view;
    LPCSTR query;
    UINT r;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    r = run_query( hdb, 0,
            "CREATE TABLE `Media` ("
            "`DiskId` SHORT NOT NULL, "
            "`LastSequence` LONG, "
            "`DiskPrompt` CHAR(64) LOCALIZABLE, "
            "`Cabinet` CHAR(255), "
            "`VolumeLabel` CHAR(32), "
            "`Source` CHAR(72) "
            "PRIMARY KEY `DiskId`)" );
    ok( r == S_OK, "cannot create Media table: %d\n", r );
 
    r = run_query( hdb, 0, "INSERT INTO `Media` "
            "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
            "VALUES ( 1, 0, '', 'zero.cab', '', '' )" );
    ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
 
    r = run_query( hdb, 0, "INSERT INTO `Media` "
            "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
            "VALUES ( 2, 1, '', 'one.cab', '', '' )" );
    ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
 
    r = run_query( hdb, 0, "INSERT INTO `Media` "
            "( `DiskId`, `LastSequence`, `DiskPrompt`, `Cabinet`, `VolumeLabel`, `Source` ) "
            "VALUES ( 3, 2, '', 'two.cab', '', '' )" );
    ok( r == S_OK, "cannot add file to the Media table: %d\n", r );
 
    query = "SELECT * FROM `Media`";
    r = do_query(hdb, query, &rec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
    check_record(rec, 6, "1", "0", "", "zero.cab", "", "");
    MsiCloseHandle( rec );
 
    query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
    r = do_query(hdb, query, &rec);
    ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
    check_record(rec, 6, "2", "1", "", "one.cab", "", "");
    MsiCloseHandle( rec );
 
    query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
 
    r = MsiViewExecute(view, 0);
    ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
 
    r = MsiViewFetch(view, &rec);
    ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
    check_record(rec, 1, "2");
    MsiCloseHandle( rec );
 
    r = MsiViewFetch(view, &rec);
    ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
    check_record(rec, 1, "3");
    MsiCloseHandle( rec );
 
    r = MsiViewFetch(view, &rec);
    ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
 
    MsiViewClose(view);
    MsiCloseHandle(view);
 
    MsiCloseHandle( rec );
 
    rec = 0;
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` IS NULL";
    r = do_query(hdb, query, &rec);
    ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
    MsiCloseHandle( rec );
 
    rec = 0;
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` < 'Cabinet'";
    r = do_query(hdb, query, &rec);
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
    MsiCloseHandle( rec );
 
    rec = 0;
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` > 'Cabinet'";
    r = do_query(hdb, query, &rec);
    ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %d\n", r );
    MsiCloseHandle( rec );
 
    rec = 0;
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` <> 'Cabinet'";
    r = do_query(hdb, query, &rec);
    ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
    MsiCloseHandle( rec );
 
    rec = 0;
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` = 'Cabinet'";
    r = do_query(hdb, query, &rec);
    ok( r == ERROR_NO_MORE_ITEMS, "query failed: %d\n", r );
    MsiCloseHandle( rec );
 
    rec = MsiCreateRecord(1);
    MsiRecordSetStringA(rec, 1, "");
 
    query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    r = MsiViewExecute(view, rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    MsiCloseHandle(rec);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    MsiCloseHandle(rec);
    MsiViewClose(view);
    MsiCloseHandle(view);
 
    MsiCloseHandle( hdb );
    DeleteFileA(msifile);
}
 
static const CHAR test_data[] = "FirstPrimaryColumn\tSecondPrimaryColumn\tShortInt\tShortIntNullable\tLongInt\tLongIntNullable\tString\tLocalizableString\tLocalizableStringNullable\n"
                                "s255\ti2\ti2\tI2\ti4\tI4\tS255\tS0\ts0\n"
                                "TestTable\tFirstPrimaryColumn\n"
                                "stringage\t5\t2\t\t2147483640\t-2147483640\tanother string\tlocalizable\tduh\n";
 
static const CHAR two_primary[] = "PrimaryOne\tPrimaryTwo\n"
                                  "s255\ts255\n"
                                  "TwoPrimary\tPrimaryOne\tPrimaryTwo\n"
                                  "papaya\tleaf\n"
                                  "papaya\tflower\n";
 
static const CHAR endlines1[] = "A\tB\tC\tD\tE\tF\r\n"
                                "s72\ts72\ts72\ts72\ts72\ts72\n"
                                "Table\tA\r\n"
                                "a\tb\tc\td\te\tf\n"
                                "g\th\ti\t\rj\tk\tl\r\n";
 
static const CHAR endlines2[] = "A\tB\tC\tD\tE\tF\r"
                                "s72\ts72\ts72\ts72\ts72\ts72\n"
                                "Table2\tA\r\n"
                                "a\tb\tc\td\te\tf\n"
                                "g\th\ti\tj\tk\tl\r\n";
 
static const CHAR suminfo[] = "PropertyId\tValue\n"
                              "i2\tl255\n"
                              "_SummaryInformation\tPropertyId\n"
                              "1\t1252\n"
                              "2\tInstaller Database\n"
                              "3\tInstaller description\n"
                              "4\tWineHQ\n"
                              "5\tInstaller\n"
                              "6\tInstaller comments\n"
                              "7\tIntel;1033,2057\n"
                              "9\t{12345678-1234-1234-1234-123456789012}\n"
                              "12\t2009/04/12 15:46:11\n"
                              "13\t2009/04/12 15:46:11\n"
                              "14\t200\n"
                              "15\t2\n"
                              "18\tVim\n"
                              "19\t2\n";
 
static void write_file(const CHAR *filename, const char *data, int data_size)
{
    DWORD size;
 
    HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
                            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    WriteFile(hf, data, data_size, &size, NULL);
    CloseHandle(hf);
}
 
static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
{
    UINT r;
 
    write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
    r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
    DeleteFileA("temp_file");
 
    return r;
}
 
static void test_suminfo_import(void)
{
    MSIHANDLE hdb, hsi, view = 0;
    LPCSTR query;
    UINT r, count, type;
    DWORD size;
    char str_value[50];
    INT int_value;
    FILETIME ft_value;
 
    GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 
    r = add_table_to_db(hdb, suminfo);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 
    /* _SummaryInformation is not imported as a regular table... */
 
    query = "SELECT * FROM `_SummaryInformation`";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %u\n", r);
    MsiCloseHandle(view);
 
    /* ...its data is added to the special summary information stream */
 
    r = MsiGetSummaryInformationA(hdb, NULL, 0, &hsi);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 
    r = MsiSummaryInfoGetPropertyCount(hsi, &count);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(count == 14, "Expected 14, got %u\n", count);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_CODEPAGE, &type, &int_value, NULL, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type ==  VT_I2, "Expected VT_I2, got %u\n", type);
    ok(int_value == 1252, "Expected 1252, got %d\n", int_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_TITLE, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(size == 18, "Expected 18, got %lu\n", size);
    ok(!strcmp(str_value, "Installer Database"),
       "Expected \"Installer Database\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_SUBJECT, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "Installer description"),
       "Expected \"Installer description\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_AUTHOR, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "WineHQ"),
       "Expected \"WineHQ\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_KEYWORDS, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "Installer"),
       "Expected \"Installer\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_COMMENTS, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "Installer comments"),
       "Expected \"Installer comments\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_TEMPLATE, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "Intel;1033,2057"),
       "Expected \"Intel;1033,2057\", got %s\n", str_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_REVNUMBER, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "{12345678-1234-1234-1234-123456789012}"),
       "Expected \"{12345678-1234-1234-1234-123456789012}\", got %s\n", str_value);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_CREATE_DTM, &type, NULL, &ft_value, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_LASTSAVE_DTM, &type, NULL, &ft_value, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_FILETIME, "Expected VT_FILETIME, got %u\n", type);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_PAGECOUNT, &type, &int_value, NULL, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
    ok(int_value == 200, "Expected 200, got %d\n", int_value);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_WORDCOUNT, &type, &int_value, NULL, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
    ok(int_value == 2, "Expected 2, got %d\n", int_value);
 
    r = MsiSummaryInfoGetPropertyA(hsi, PID_SECURITY, &type, &int_value, NULL, NULL, NULL);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type ==  VT_I4, "Expected VT_I4, got %u\n", type);
    ok(int_value == 2, "Expected 2, got %d\n", int_value);
 
    size = sizeof(str_value);
    r = MsiSummaryInfoGetPropertyA(hsi, PID_APPNAME, &type, NULL, NULL, str_value, &size);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
    ok(type == VT_LPSTR, "Expected VT_LPSTR, got %u\n", type);
    ok(!strcmp(str_value, "Vim"), "Expected \"Vim\", got %s\n", str_value);
 
    MsiCloseHandle(hsi);
    MsiCloseHandle(hdb);
    DeleteFileA(msifile);
}
 
static void test_msiimport(void)
{
    MSIHANDLE hdb, view, rec;
    LPCSTR query;
    UINT r;
 
    GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiDatabaseImportA(hdb, CURR_DIR, NULL);
    ok(r == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", r);
 
    r = MsiDatabaseImportA(hdb, CURR_DIR, "nonexistent");
    ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
 
    r = add_table_to_db(hdb, test_data);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = add_table_to_db(hdb, two_primary);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = add_table_to_db(hdb, endlines1);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = add_table_to_db(hdb, endlines2);
    ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
 
    query = "SELECT * FROM `TestTable`";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 9, "FirstPrimaryColumn", "SecondPrimaryColumn", "ShortInt",
            "ShortIntNullable", "LongInt", "LongIntNullable", "String",
            "LocalizableString", "LocalizableStringNullable");
    MsiCloseHandle(rec);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 9, "s255", "i2", "i2", "I2", "i4", "I4", "S255", "S0", "s0");
    MsiCloseHandle(rec);
 
    query = "SELECT * FROM `TestTable`";
    r = do_query(hdb, query, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 9, "stringage", "5", "2", "", "2147483640", "-2147483640",
            "another string", "localizable", "duh");
    MsiCloseHandle(rec);
 
    MsiViewClose(view);
    MsiCloseHandle(view);
 
    query = "SELECT * FROM `TwoPrimary`";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 2, "PrimaryOne", "PrimaryTwo");
    MsiCloseHandle(rec);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 2, "s255", "s255");
    MsiCloseHandle(rec);
 
    r = MsiViewExecute(view, 0);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 2, "papaya", "leaf");
    MsiCloseHandle(rec);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 2, "papaya", "flower");
    MsiCloseHandle(rec);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_NO_MORE_ITEMS,
       "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
 
    r = MsiViewClose(view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    MsiCloseHandle(view);
 
    query = "SELECT * FROM `Table`";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 6, "A", "B", "C", "D", "E", "F");
    MsiCloseHandle(rec);
 
    r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 6, "s72", "s72", "s72", "s72", "s72", "s72");
    MsiCloseHandle(rec);
 
    MsiViewClose(view);
    MsiCloseHandle(view);
 
    query = "SELECT * FROM `Table`";
    r = MsiDatabaseOpenViewA(hdb, query, &view);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewExecute(view, 0);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 6, "a", "b", "c", "d", "e", "f");
    MsiCloseHandle(rec);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    check_record(rec, 6, "g", "h", "i", "j", "k", "l");
    MsiCloseHandle(rec);
 
    r = MsiViewFetch(view, &rec);
    ok(r == ERROR_NO_MORE_ITEMS,
       "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
 
    MsiViewClose(view);
    MsiCloseHandle(view);
    MsiCloseHandle(hdb);
    DeleteFileA(msifile);
}
 
static const CHAR bin_import_dat[] = "Name\tData\r\n"
                                     "s72\tV0\r\n"
                                     "Binary\tName\r\n"
                                     "filename1\tfilename1.ibd\r\n";
 
static void test_binary_import(void)
{
    MSIHANDLE hdb = 0, rec;
    char file[MAX_PATH];
    char buf[MAX_PATH];
    char path[MAX_PATH];
    DWORD size;
    LPCSTR query;
    UINT r;
 
    /* create files to import */
    write_file("bin_import.idt", bin_import_dat,
          (sizeof(bin_import_dat) - 1) * sizeof(char));
    CreateDirectoryA("bin_import", NULL);
    create_file_data("bin_import/filename1.ibd", "just some words", 15);
 
    /* import files into database */
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
    ok( r == ERROR_SUCCESS , "Failed to open database\n");
 
    GetCurrentDirectoryA(MAX_PATH, path);
    r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
    ok(r == ERROR_SUCCESS , "Failed to import Binary table\n");
 
    /* read file from the Binary table */
    query = "SELECT * FROM `Binary`";
    r = do_query(hdb, query, &rec);
    ok(r == ERROR_SUCCESS, "SELECT query failed: %d\n", r);
 
    size = MAX_PATH;
    r = MsiRecordGetStringA(rec, 1, file, &size);
    ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
    ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
 
    size = MAX_PATH;
    memset(buf, 0, MAX_PATH);
    r = MsiRecordReadStream(rec, 2, buf, &size);
    ok(r == ERROR_SUCCESS, "Failed to get stream: %d\n", r);
    ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
 
    r = MsiCloseHandle(rec);
    ok(r == ERROR_SUCCESS , "Failed to close record handle\n");
 
    r = MsiCloseHandle(hdb);
    ok(r == ERROR_SUCCESS , "Failed to close database\n");
 
    DeleteFileA("bin_import/filename1.ibd");
    RemoveDirectoryA("bin_import");
    DeleteFileA("bin_import.idt");
}
 
static void test_markers(void)
{
    MSIHANDLE hdb, rec;
    LPCSTR query;
    UINT r;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    rec = MsiCreateRecord(3);
    MsiRecordSetStringA(rec, 1, "Table");
    MsiRecordSetStringA(rec, 2, "Apples");
    MsiRecordSetStringA(rec, 3, "Oranges");
 
    /* try a legit create */
    query = "CREATE TABLE `Table` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try table name as marker */
    rec = MsiCreateRecord(1);
    MsiRecordSetStringA(rec, 1, "Fable");
    query = "CREATE TABLE `?` ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    /* verify that we just created a table called '?', not 'Fable' */
    r = try_query(hdb, "SELECT * from `Fable`");
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
 
    r = try_query(hdb, "SELECT * from `?`");
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    /* try table name as marker without backticks */
    MsiRecordSetStringA(rec, 1, "Mable");
    query = "CREATE TABLE ? ( `One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
 
    /* try one column name as marker */
    MsiRecordSetStringA(rec, 1, "One");
    query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try column names as markers */
    rec = MsiCreateRecord(2);
    MsiRecordSetStringA(rec, 1, "One");
    MsiRecordSetStringA(rec, 2, "Two");
    query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `One`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try names with backticks */
    rec = MsiCreateRecord(3);
    MsiRecordSetStringA(rec, 1, "One");
    MsiRecordSetStringA(rec, 2, "Two");
    MsiRecordSetStringA(rec, 3, "One");
    query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
 
    /* try names with backticks, minus definitions */
    query = "CREATE TABLE `Mable` ( `?`, `?` PRIMARY KEY `?`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
 
    /* try names without backticks */
    query = "CREATE TABLE `Mable` ( ? SHORT NOT NULL, ? CHAR(255) PRIMARY KEY ?)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try one long marker */
    rec = MsiCreateRecord(1);
    MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
    query = "CREATE TABLE `Mable` ( ? )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try all names as markers */
    rec = MsiCreateRecord(4);
    MsiRecordSetStringA(rec, 1, "Mable");
    MsiRecordSetStringA(rec, 2, "One");
    MsiRecordSetStringA(rec, 3, "Two");
    MsiRecordSetStringA(rec, 4, "One");
    query = "CREATE TABLE `?` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try a legit insert */
    query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( 5, 'hello' )";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    r = try_query(hdb, "SELECT * from `Table`");
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
 
    /* try values as markers */
    rec = MsiCreateRecord(2);
    MsiRecordSetInteger(rec, 1, 4);
    MsiRecordSetStringA(rec, 2, "hi");
    query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try column names and values as markers */
    rec = MsiCreateRecord(4);
    MsiRecordSetStringA(rec, 1, "One");
    MsiRecordSetStringA(rec, 2, "Two");
    MsiRecordSetInteger(rec, 3, 5);
    MsiRecordSetStringA(rec, 4, "hi");
    query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( ?, '?' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try column names as markers */
    rec = MsiCreateRecord(2);
    MsiRecordSetStringA(rec, 1, "One");
    MsiRecordSetStringA(rec, 2, "Two");
    query = "INSERT INTO `Table` ( `?`, `?` ) VALUES ( 3, 'yellow' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try table name as a marker */
    rec = MsiCreateRecord(1);
    MsiRecordSetStringA(rec, 1, "Table");
    query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( 2, 'green' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try table name and values as markers */
    rec = MsiCreateRecord(3);
    MsiRecordSetStringA(rec, 1, "Table");
    MsiRecordSetInteger(rec, 2, 10);
    MsiRecordSetStringA(rec, 3, "haha");
    query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* try all markers */
    rec = MsiCreateRecord(5);
    MsiRecordSetStringA(rec, 1, "Table");
    MsiRecordSetStringA(rec, 1, "One");
    MsiRecordSetStringA(rec, 1, "Two");
    MsiRecordSetInteger(rec, 2, 10);
    MsiRecordSetStringA(rec, 3, "haha");
    query = "INSERT INTO `?` ( `?`, `?` ) VALUES ( ?, '?' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* insert an integer as a string */
    rec = MsiCreateRecord(2);
    MsiRecordSetStringA(rec, 1, "11");
    MsiRecordSetStringA(rec, 2, "hi");
    query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiCloseHandle(rec);
 
    /* leave off the '' for the string */
    rec = MsiCreateRecord(2);
    MsiRecordSetInteger(rec, 1, 12);
    MsiRecordSetStringA(rec, 2, "hi");
    query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, ? )";
    r = run_query(hdb, rec, query);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    MsiCloseHandle(rec);
 
    MsiCloseHandle(hdb);
    DeleteFileA(msifile);
}
 
#define MY_NVIEWS 4000    /* Largest installer I've seen uses < 2000 */
static void test_handle_limit(void)
{
    int i;
    MSIHANDLE hdb;
    MSIHANDLE hviews[MY_NVIEWS];
    UINT r;
 
    /* create an empty db */
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    memset(hviews, 0, sizeof(hviews));
 
    for (i=0; i<MY_NVIEWS; i++) {
        static char szQueryBuf[256] = "SELECT * from `_Tables`";
        hviews[i] = 0xdeadbeeb;
        r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
        if( r != ERROR_SUCCESS || hviews[i] == 0xdeadbeeb ||
            hviews[i] == 0 || (i && (hviews[i] == hviews[i-1])))
            break;
    }
 
    ok( i == MY_NVIEWS, "problem opening views\n");
 
    for (i=0; i<MY_NVIEWS; i++) {
        if (hviews[i] != 0 && hviews[i] != 0xdeadbeeb) {
            MsiViewClose(hviews[i]);
            r = MsiCloseHandle(hviews[i]);
            if (r != ERROR_SUCCESS)
                break;
        }
    }
 
    ok( i == MY_NVIEWS, "problem closing views\n");
 
    r = MsiCloseHandle(hdb);
    ok( r == ERROR_SUCCESS, "failed to close database\n");
}
 
static void generate_transform(void)
{
    MSIHANDLE hdb1, hdb2, hrec;
    LPCSTR query;
    UINT r;
 
    /* start with two identical databases */
    CopyFileA(msifile2, msifile, FALSE);
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
    ok( r == ERROR_SUCCESS , "Failed to create database\n" );
 
    r = MsiDatabaseCommit( hdb1 );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
    ok( r == ERROR_SUCCESS , "Failed to create database\n" );
 
    /* the transform between two identical database should be empty */
    r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
    todo_wine {
    ok( r == ERROR_NO_DATA, "return code %d, should be ERROR_NO_DATA\n", r );
    }
 
    query = "CREATE TABLE `AAR` ( `BAR` SHORT NOT NULL, `CAR` CHAR(255) PRIMARY KEY `CAR`)";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add table\n");
 
    query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 1, 'vw' )";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add row 1\n");
 
    query = "INSERT INTO `AAR` ( `BAR`, `CAR` ) VALUES ( 2, 'bmw' )";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add row 2\n");
 
    query = "UPDATE `MOO` SET `OOO` = 'c' WHERE `NOO` = 1";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to modify row\n");
 
    query = "DELETE FROM `MOO` WHERE `NOO` = 3";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to delete row\n");
 
    hrec = MsiCreateRecord(2);
    r = MsiRecordSetInteger(hrec, 1, 1);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
 
    write_file("testdata.bin", "naengmyon", 9);
    r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
    ok(r == ERROR_SUCCESS, "failed to set stream\n");
 
    query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
    r = run_query(hdb1, hrec, query);
    ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
 
    MsiCloseHandle(hrec);
 
    query = "ALTER TABLE `MOO` ADD `COW` INTEGER";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add column\n");
 
    query = "ALTER TABLE `MOO` ADD `PIG` INTEGER";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add column\n");
 
    query = "UPDATE `MOO` SET `PIG` = 5 WHERE `NOO` = 1";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to modify row\n");
 
    query = "CREATE TABLE `Property` ( `Property` CHAR(72) NOT NULL, "
            "`Value` CHAR(0) PRIMARY KEY `Property`)";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add property table\n");
 
    query = "INSERT INTO `Property` ( `Property`, `Value` ) VALUES ( 'prop', 'val' )";
    r = run_query(hdb1, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add property\n");
 
    /* database needs to be committed */
    MsiDatabaseCommit(hdb1);
 
    r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
    ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
 
    MsiCloseHandle( hdb1 );
    MsiCloseHandle( hdb2 );
 
    DeleteFileA("testdata.bin");
}
 
/* data for generating a transform */
 
/* tables transform names - encoded as they would be in an msi database file */
static const WCHAR name1[] = { 0x4840, 0x3a8a, 0x481b, 0 }; /* AAR */
static const WCHAR name2[] = { 0x4840, 0x3b3f, 0x43f2, 0x4438, 0x45b1, 0 }; /* _Columns */
static const WCHAR name3[] = { 0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0 }; /* _Tables */
static const WCHAR name4[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0 }; /* _StringData */
static const WCHAR name5[] = { 0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0 }; /* _StringPool */
static const WCHAR name6[] = { 0x4840, 0x3e16, 0x4818, 0}; /* MOO */
static const WCHAR name7[] = { 0x4840, 0x3c8b, 0x3a97, 0x409b, 0 }; /* BINARY */
static const WCHAR name8[] = { 0x3c8b, 0x3a97, 0x409b, 0x387e, 0 }; /* BINARY.1 */
static const WCHAR name9[] = { 0x4840, 0x4559, 0x44f2, 0x4568, 0x4737, 0 }; /* Property */
 
/* data in each table */
static const WCHAR data1[] = { /* AAR */
    0x0201, 0x0008, 0x8001,  /* 0x0201 = add row (1), two shorts */
    0x0201, 0x0009, 0x8002,
};
static const WCHAR data2[] = { /* _Columns */
    0x0401, 0x0001, 0x8003, 0x0002, 0x9502,
    0x0401, 0x0001, 0x8004, 0x0003, 0x9502,
    0x0401, 0x0005, 0x0000, 0x0006, 0xbdff,  /* 0x0401 = add row (1), 4 shorts */
    0x0401, 0x0005, 0x0000, 0x0007, 0x8502,
    0x0401, 0x000a, 0x0000, 0x000a, 0xad48,
    0x0401, 0x000a, 0x0000, 0x000b, 0x9d00,
};
static const WCHAR data3[] = { /* _Tables */
    0x0101, 0x0005, /* 0x0101 = add row (1), 1 short */
    0x0101, 0x000a,
};
static const char data4[] = /* _StringData */
    "MOOCOWPIGcAARCARBARvwbmwPropertyValuepropval";  /* all the strings squashed together */
static const WCHAR data5[] = { /* _StringPool */
/*  len, refs */
    0,   0,    /* string 0 ''    */
    3,   2,    /* string 1 'MOO' */
    3,   1,    /* string 2 'COW' */
    3,   1,    /* string 3 'PIG' */
    1,   1,    /* string 4 'c'   */
    3,   3,    /* string 5 'AAR' */
    3,   1,    /* string 6 'CAR' */
    3,   1,    /* string 7 'BAR' */
    2,   1,    /* string 8 'vw'  */
    3,   1,    /* string 9 'bmw' */
    8,   4,    /* string 10 'Property' */
    5,   1,    /* string 11 'Value' */
    4,   1,    /* string 12 'prop' */
    3,   1,    /* string 13 'val' */
};
/* update row, 0x0002 is a bitmask of present column data, keys are excluded */
static const WCHAR data6[] = { /* MOO */
    0x000a, 0x8001, 0x0004, 0x8005, /* update row */
    0x0000, 0x8003,         /* delete row */
};
 
static const WCHAR data7[] = { /* BINARY */
    0x0201, 0x8001, 0x0001,
};
 
static const char data8[] =  /* stream data for the BINARY table */
    "naengmyon";
 
static const WCHAR data9[] = { /* Property */
    0x0201, 0x000c, 0x000d,
};
 
static const struct {
    LPCWSTR name;
    const void *data;
    DWORD size;
} table_transform_data[] =
{
    { name1, data1, sizeof data1 },
    { name2, data2, sizeof data2 },
    { name3, data3, sizeof data3 },
    { name4, data4, sizeof data4 - 1 },
    { name5, data5, sizeof data5 },
    { name6, data6, sizeof data6 },
    { name7, data7, sizeof data7 },
    { name8, data8, sizeof data8 - 1 },
    { name9, data9, sizeof data9 },
};
 
static void generate_transform_manual(void)
{
    IStorage *stg = NULL;
    IStream *stm;
    WCHAR name[0x20];
    HRESULT r;
    DWORD i, count;
    const DWORD mode = STGM_CREATE|STGM_READWRITE|STGM_DIRECT|STGM_SHARE_EXCLUSIVE;
 
    const CLSID CLSID_MsiTransform = { 0xc1082,0,0,{0xc0,0,0,0,0,0,0,0x46}};
 
    MultiByteToWideChar(CP_ACP, 0, mstfile, -1, name, 0x20);
 
    r = StgCreateDocfile(name, mode, 0, &stg);
    ok(r == S_OK, "failed to create storage\n");
    if (!stg)
        return;
 
    r = IStorage_SetClass( stg, &CLSID_MsiTransform );
    ok(r == S_OK, "failed to set storage type\n");
 
    for (i=0; i<ARRAY_SIZE(table_transform_data); i++)
    {
        r = IStorage_CreateStream( stg, table_transform_data[i].name,
                            STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
        if (FAILED(r))
        {
            ok(0, "failed to create stream %#lx\n", r);
            continue;
        }
 
        r = IStream_Write( stm, table_transform_data[i].data,
                          table_transform_data[i].size, &count );
        if (FAILED(r) || count != table_transform_data[i].size)
            ok(0, "failed to write stream\n");
        IStream_Release(stm);
    }
 
    IStorage_Release(stg);
}
 
static UINT set_summary_info(MSIHANDLE hdb)
{
    UINT res;
    MSIHANDLE suminfo;
 
    /* build summary info */
    res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
    ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
                        "Installation Database");
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
                        "Installation Database");
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
                        "Wine Hackers");
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
                    ";1033,2057");
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
                    "{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    res = MsiSummaryInfoPersist(suminfo);
    ok( res == ERROR_SUCCESS , "Failed to make summary info persist\n" );
 
    res = MsiCloseHandle( suminfo);
    ok( res == ERROR_SUCCESS , "Failed to close suminfo\n" );
 
    return res;
}
 
static MSIHANDLE create_package_db(const WCHAR *filename)
{
    MSIHANDLE hdb = 0;
    UINT res;
 
    DeleteFileW(msifileW);
 
    /* create an empty database */
    res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
    ok( res == ERROR_SUCCESS , "Failed to create database\n" );
    if( res != ERROR_SUCCESS )
        return hdb;
 
    res = MsiDatabaseCommit( hdb );
    ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
 
    res = set_summary_info(hdb);
    ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
 
    create_directory_table(hdb);
 
    return hdb;
}
 
static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
{
    UINT res;
    CHAR szPackage[12];
    MSIHANDLE hPackage;
 
    sprintf(szPackage, "#%lu", hdb);
    res = MsiOpenPackageA(szPackage, &hPackage);
    if (res != ERROR_SUCCESS)
        return res;
 
    res = MsiCloseHandle(hdb);
    if (res != ERROR_SUCCESS)
    {
        MsiCloseHandle(hPackage);
        return res;
    }
 
    *handle = hPackage;
    return ERROR_SUCCESS;
}
 
static void test_try_transform(void)
{
    static const struct {
        const char *table;
        const char *column;
        const char *row;
        const char *data;
        const char *current;
    } transform_view[] = {
        { "MOO", "OOO", "1", "c", "a" },
        { "MOO", "COW", "", "5378", "3" },
        { "MOO", "PIG", "", "5378", "4" },
        { "MOO", "PIG", "1", "5", "" },
        { "MOO", "DELETE", "3", "", "" },
        { "BINARY", "BLOB", "1", "BINARY.1", "" },
        { "BINARY", "INSERT", "1", "", "" },
        { "AAR", "CREATE", "", "", "" },
        { "AAR", "CAR", "", "15871", "1" },
        { "AAR", "BAR", "", "1282", "2" },
        { "AAR", "BAR", "vw", "1", "" },
        { "AAR", "BAR", "bmw", "2", "" },
        { "AAR", "INSERT", "vw", "", "" },
        { "AAR", "INSERT", "bmw", "", "" },
        { "Property", "CREATE", "", "", "" },
        { "Property", "Property", "", "11592", "1" },
        { "Property", "Value", "", "7424", "2" },
        { "Property", "Value", "prop", "val", "" },
        { "Property", "INSERT", "prop", "", "" }
    };
 
    MSIHANDLE hdb, hview, hrec, hpkg = 0;
    LPCSTR query;
    UINT r;
    DWORD sz;
    char buffer[MAX_PATH];
    int i, matched;
 
    DeleteFileA(msifile);
    DeleteFileA(mstfile);
 
    /* create the database */
    hdb = create_package_db(msifileW);
    ok(hdb, "Failed to create package db\n");
 
    query = "CREATE TABLE `MOO` ( `NOO` SHORT NOT NULL, `OOO` CHAR(255) PRIMARY KEY `NOO`)";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add table\n");
 
    query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 1, 'a' )";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add row\n");
 
    query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 2, 'b' )";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add row\n");
 
    query = "INSERT INTO `MOO` ( `NOO`, `OOO` ) VALUES ( 3, 'c' )";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add row\n");
 
    query = "CREATE TABLE `BINARY` ( `ID` SHORT NOT NULL, `BLOB` OBJECT PRIMARY KEY `ID`)";
    r = run_query(hdb, 0, query);
    ok(r == ERROR_SUCCESS, "failed to add table\n");
 
    hrec = MsiCreateRecord(2);
    r = MsiRecordSetInteger(hrec, 1, 2);
    ok(r == ERROR_SUCCESS, "failed to set integer\n");
 
    write_file("testdata.bin", "lamyon", 6);
    r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
    ok(r == ERROR_SUCCESS, "failed to set stream\n");
 
    query = "INSERT INTO `BINARY` ( `ID`, `BLOB` ) VALUES ( ?, ? )";
    r = run_query(hdb, hrec, query);
    ok(r == ERROR_SUCCESS, "failed to add row with blob\n");
 
    MsiCloseHandle(hrec);
 
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    MsiCloseHandle( hdb );
    DeleteFileA("testdata.bin");
 
    /*
     * Both these generate an equivalent transform,
     *  but the first doesn't work in Wine yet
     *  because MsiDatabaseGenerateTransform is unimplemented.
     */
    if (0)
        generate_transform();
    else
        generate_transform_manual();
 
    r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
    ok( r == ERROR_SUCCESS , "Failed to create database\n" );
 
    r = MsiDatabaseApplyTransformA(hdb, mstfile, MSITRANSFORM_ERROR_VIEWTRANSFORM);
    ok(r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r);
 
    query = "select * from `_TransformView`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
 
    r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
    ok(r == ERROR_SUCCESS, "error\n");
    check_record(hrec, 5, "Table", "Column", "Row", "Data", "Current");
    MsiCloseHandle(hrec);
 
    r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
    ok(r == ERROR_SUCCESS, "error\n");
    check_record(hrec, 5, "g0", "g0", "G0", "G0", "G0");
    MsiCloseHandle(hrec);
 
    matched = 0;
    while (MsiViewFetch(hview, &hrec) == ERROR_SUCCESS)
    {
        char data[5][256];
 
        for (i = 1; i <= 5; i++) {
            sz = ARRAY_SIZE(data[0]);
            r = MsiRecordGetStringA(hrec, i, data[i-1], &sz);
            ok(r == ERROR_SUCCESS, "%d) MsiRecordGetStringA failed %d\n", i, r);
        }
 
        for (i = 0; i < ARRAY_SIZE(transform_view); i++)
        {
            if (strcmp(data[0], transform_view[i].table) ||
                    strcmp(data[1], transform_view[i].column) ||
                    strcmp(data[2], transform_view[i].row))
                continue;
 
            matched++;
            ok(!strcmp(data[3], transform_view[i].data), "%d) data[3] = %s\n", i, data[3]);
            ok(!strcmp(data[4], transform_view[i].current), "%d) data[4] = %s\n", i, data[4]);
            break;
        }
        ok(i != ARRAY_SIZE(transform_view), "invalid row: %s, %s, %s\n",
                wine_dbgstr_a(data[0]), wine_dbgstr_a(data[1]), wine_dbgstr_a(data[2]));
        MsiCloseHandle(hrec);
    }
    ok(matched == ARRAY_SIZE(transform_view), "matched = %d\n", matched);
 
    r = MsiViewClose(hview);
    ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
    r = MsiCloseHandle(hview);
    ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
 
    query = "ALTER TABLE `_TransformView` FREE";
    r = run_query( hdb, 0, query );
    ok( r == ERROR_SUCCESS, "cannot free _TransformView table: %d\n", r );
    r = run_query( hdb, 0, query );
    ok( r == ERROR_BAD_QUERY_SYNTAX, "_TransformView table still exist: %d\n", r );
 
    r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
    ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
 
    r = MsiDatabaseCommit( hdb );
    ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
 
    /* check new values */
    hrec = 0;
    query = "select `BAR`,`CAR` from `AAR` where `BAR` = 1 AND `CAR` = 'vw'";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "select query failed\n");
    MsiCloseHandle(hrec);
 
    query = "select `BAR`,`CAR` from `AAR` where `BAR` = 2 AND `CAR` = 'bmw'";
    hrec = 0;
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "select query failed\n");
    MsiCloseHandle(hrec);
 
    /* check updated values */
    hrec = 0;
    query = "select `NOO`,`OOO` from `MOO` where `NOO` = 1 AND `OOO` = 'c'";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "select query failed\n");
    MsiCloseHandle(hrec);
 
    /* check unchanged value */
    hrec = 0;
    query = "select `NOO`,`OOO` from `MOO` where `NOO` = 2 AND `OOO` = 'b'";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "select query failed\n");
    MsiCloseHandle(hrec);
 
    /* check deleted value */
    hrec = 0;
    query = "select * from `MOO` where `NOO` = 3";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "select query failed\n");
    if (hrec) MsiCloseHandle(hrec);
 
    /* check added stream */
    hrec = 0;
    query = "select `BLOB` from `BINARY` where `ID` = 1";
    r = do_query(hdb, query, &hrec);
    ok(r == ERROR_SUCCESS, "select query failed\n");
 
    /* check the contents of the stream */
    sz = sizeof buffer;
    r = MsiRecordReadStream( hrec, 1, buffer, &sz );
    ok(r == ERROR_SUCCESS, "read stream failed\n");
    ok(!memcmp(buffer, "naengmyon", 9), "stream data was wrong\n");
    ok(sz == 9, "stream data was wrong size\n");
    if (hrec) MsiCloseHandle(hrec);
 
    /* check the validity of the table with a deleted row */
    hrec = 0;
    query = "select * from `MOO`";
    r = MsiDatabaseOpenViewA(hdb, query, &hview);
    ok(r == ERROR_SUCCESS, "open view failed\n");
 
    r = MsiViewExecute(hview, 0);
    ok(r == ERROR_SUCCESS, "view execute failed\n");
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "view fetch failed\n");
    check_record(hrec, 4, "1", "c", "", "5");
    MsiCloseHandle(hrec);
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_SUCCESS, "view fetch failed\n");
    check_record(hrec, 4, "2", "b", "", "");
    MsiCloseHandle(hrec);
 
    r = MsiViewFetch(hview, &hrec);
    ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
 
    MsiCloseHandle(hrec);
    MsiViewClose(hview);
    MsiCloseHandle(hview);
 
    /* check that the property was added */
    r = package_from_db(hdb, &hpkg);
    if (r == ERROR_INSTALL_PACKAGE_REJECTED)
    {
        skip("Not enough rights to perform tests\n");
        goto error;
    }
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %u\n", r);
 
    sz = MAX_PATH;
    r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
    ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
    ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
 
    MsiCloseHandle(hpkg);
 
error:
    MsiCloseHandle(hdb);
    DeleteFileA(msifile);
    DeleteFileA(mstfile);
}
 
static const char *join_res_first[][2] =
{
    { "alveolar", "procerus" },
    { "septum", "procerus" },
    { "septum", "nasalis" },
    { "ramus", "nasalis" },
    { "malar", "mentalis" },
};
 
static const char *join_res_second[][2] =
{
    { "nasal", "septum" },
    { "mandible", "ramus" },
};
 
static const char *join_res_third[][2] =
{
    { "msvcp.dll", "abcdefgh" },
    { "msvcr.dll", "ijklmnop" },
};
 
static const char *join_res_fourth[][2] =
{
    { "msvcp.dll.01234", "single.dll.31415" },
};
 
static const char *join_res_fifth[][2] =
{
    { "malar", "procerus" },
};
 
static const char *join_res_sixth[][2] =
{
    { "malar", "procerus" },
    { "malar", "procerus" },
    { "malar", "nasalis" },
    { "malar", "nasalis" },
    { "malar", "nasalis" },
    { "malar", "mentalis" },
};
 
static const char *join_res_seventh[][2] =
{
    { "malar", "nasalis" },
    { "malar", "nasalis" },
    { "malar", "nasalis" },
};
 
static const char *join_res_eighth[][4] =
{
    { "msvcp.dll", "msvcp.dll.01234", "msvcp.dll.01234", "abcdefgh" },
    { "msvcr.dll", "msvcr.dll.56789", "msvcp.dll.01234", "abcdefgh" },
    { "msvcp.dll", "msvcp.dll.01234", "msvcr.dll.56789", "ijklmnop" },
    { "msvcr.dll", "msvcr.dll.56789", "msvcr.dll.56789", "ijklmnop" },
    { "msvcp.dll", "msvcp.dll.01234", "single.dll.31415", "msvcp.dll" },
    { "msvcr.dll", "msvcr.dll.56789", "single.dll.31415", "msvcp.dll" },
};
 
static const char *join_res_ninth[][6] =
{
    { "1", "2", "3", "4", "7", "8" },
    { "1", "2", "5", "6", "7", "8" },
    { "1", "2", "3", "4", "9", "10" },
    { "1", "2", "5", "6", "9", "10" },
    { "1", "2", "3", "4", "11", "12" },
    { "1", "2", "5", "6", "11", "12" },
};
 
static void test_join(void)
{
    MSIHANDLE hdb, hview, hrec;
    LPCSTR query;
    UINT r;
    DWORD i;
 
    hdb = create_db();
    ok( hdb, "failed to create db\n");
 
    create_component_table( hdb );
    add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
    add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
    add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
    add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
 
    create_feature_components_table( hdb );
    add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
    add_feature_components_entry( hdb, "'procerus', 'nasal'" );
    add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
    add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
    add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
    add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );