2007-03-06 11:59:18 +00:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
#define COBJMACROS
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include <windows.h>
|
|
|
|
#include <msi.h>
|
2009-06-06 15:59:11 +00:00
|
|
|
#include <msidefs.h>
|
2007-03-06 11:59:18 +00:00
|
|
|
#include <msiquery.h>
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
#include <objidl.h>
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
#include "wine/test.h"
|
|
|
|
|
2009-12-22 09:14:17 +00:00
|
|
|
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[] = {'w','i','n','e','t','e','s','t','-','d','b','.','m','s','i',0};
|
2014-04-23 14:49:34 +00:00
|
|
|
static const WCHAR msifile2W[] = {'w','i','n','e','t','s','t','2','-','d','b','.','m','s','i',0};
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
static void test_msidatabase(void)
|
|
|
|
{
|
2008-02-10 13:22:36 +00:00
|
|
|
MSIHANDLE hdb = 0, hdb2 = 0;
|
2007-03-06 11:59:18 +00:00
|
|
|
UINT res;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(msifileW);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_OPEN_FAILED, "expected failure\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, (LPWSTR)0xff, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_INVALID_PARAMETER, "expected failure\n");
|
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* create an empty database */
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
|
2007-03-06 11:59:18 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to create database\n" );
|
|
|
|
|
|
|
|
res = MsiDatabaseCommit( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
res = MsiDatabaseCommit( hdb2 );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
|
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb2 );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb2 );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile2 ) == INVALID_FILE_ATTRIBUTES, "uncommitted database should not exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, msifile2W, &hdb2 );
|
2008-02-10 13:22:36 +00:00
|
|
|
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" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile2 ) != INVALID_FILE_ATTRIBUTES, "committed database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
res = MsiDatabaseCommit( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_DIRECT, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_TRANSACT, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
/* MSIDBOPEN_CREATE deletes the database if MsiCommitDatabase isn't called */
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile ) == INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
|
|
|
res = MsiDatabaseCommit( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to commit database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( GetFileAttributesA( msifile ) != INVALID_FILE_ATTRIBUTES, "database should exist\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
res = MsiCloseHandle( hdb );
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to close database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = DeleteFileA( msifile2 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == TRUE, "Failed to delete database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = DeleteFileA( msifile );
|
2007-03-06 11:59:18 +00:00
|
|
|
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;
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
if (phrec)
|
|
|
|
*phrec = 0;
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* open a select query */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static UINT run_query( MSIHANDLE hdb, MSIHANDLE hrec, const char *query )
|
|
|
|
{
|
|
|
|
MSIHANDLE hview = 0;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
if( r != ERROR_SUCCESS )
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, hrec);
|
|
|
|
if( r == ERROR_SUCCESS )
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static UINT create_component_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return 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`)" );
|
|
|
|
}
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
static UINT create_custom_action_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return 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`)" );
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT create_directory_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return run_query( hdb, 0,
|
|
|
|
"CREATE TABLE `Directory` ( "
|
|
|
|
"`Directory` CHAR(255) NOT NULL, "
|
|
|
|
"`Directory_Parent` CHAR(255), "
|
|
|
|
"`DefaultDir` CHAR(255) NOT NULL "
|
|
|
|
"PRIMARY KEY `Directory`)" );
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static UINT create_feature_components_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return run_query( hdb, 0,
|
|
|
|
"CREATE TABLE `FeatureComponents` ( "
|
|
|
|
"`Feature_` CHAR(38) NOT NULL, "
|
|
|
|
"`Component_` CHAR(72) NOT NULL "
|
|
|
|
"PRIMARY KEY `Feature_`, `Component_` )" );
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT create_std_dlls_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return run_query( hdb, 0,
|
|
|
|
"CREATE TABLE `StdDlls` ( "
|
|
|
|
"`File` CHAR(255) NOT NULL, "
|
|
|
|
"`Binary_` CHAR(72) NOT NULL "
|
|
|
|
"PRIMARY KEY `File` )" );
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT create_binary_table( MSIHANDLE hdb )
|
|
|
|
{
|
|
|
|
return run_query( hdb, 0,
|
|
|
|
"CREATE TABLE `Binary` ( "
|
|
|
|
"`Name` CHAR(72) NOT NULL, "
|
|
|
|
"`Data` CHAR(72) NOT NULL "
|
|
|
|
"PRIMARY KEY `Name` )" );
|
|
|
|
}
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
#define make_add_entry(type, qtext) \
|
|
|
|
static UINT add##_##type##_##entry( MSIHANDLE hdb, const char *values ) \
|
|
|
|
{ \
|
|
|
|
char insert[] = qtext; \
|
|
|
|
char *query; \
|
|
|
|
UINT sz, r; \
|
|
|
|
sz = strlen(values) + sizeof insert; \
|
|
|
|
query = HeapAlloc(GetProcessHeap(),0,sz); \
|
|
|
|
sprintf(query,insert,values); \
|
|
|
|
r = run_query( hdb, 0, query ); \
|
|
|
|
HeapFree(GetProcessHeap(), 0, query); \
|
|
|
|
return r; \
|
|
|
|
}
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
make_add_entry(component,
|
|
|
|
"INSERT INTO `Component` "
|
|
|
|
"(`Component`, `ComponentId`, `Directory_`, "
|
|
|
|
"`Attributes`, `Condition`, `KeyPath`) VALUES( %s )")
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
make_add_entry(custom_action,
|
|
|
|
"INSERT INTO `CustomAction` "
|
|
|
|
"(`Action`, `Type`, `Source`, `Target`) VALUES( %s )")
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
make_add_entry(feature_components,
|
|
|
|
"INSERT INTO `FeatureComponents` "
|
|
|
|
"(`Feature_`, `Component_`) VALUES( %s )")
|
|
|
|
|
|
|
|
make_add_entry(std_dlls,
|
|
|
|
"INSERT INTO `StdDlls` (`File`, `Binary_`) VALUES( %s )")
|
|
|
|
|
|
|
|
make_add_entry(binary,
|
|
|
|
"INSERT INTO `Binary` (`Name`, `Data`) VALUES( %s )")
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
static void test_msiinsert(void)
|
|
|
|
{
|
2012-01-21 17:21:57 +00:00
|
|
|
MSIHANDLE hdb = 0, hview = 0, hview2 = 0, hrec = 0;
|
2007-03-06 11:59:18 +00:00
|
|
|
UINT r;
|
|
|
|
const char *query;
|
|
|
|
char buf[80];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
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`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
query = "SELECT * FROM phone WHERE number = '8675309'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview2);
|
2012-01-21 17:21:57 +00:00
|
|
|
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");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* insert a value into it */
|
|
|
|
query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
|
|
|
|
"VALUES('1', 'Abe', '8675309')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
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");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &sz);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "field 2 content fetch failed\n");
|
|
|
|
ok(!strcmp(buf,"Abe"), "field 2 content incorrect\n");
|
|
|
|
sz = sizeof buf;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &sz);
|
2007-03-06 11:59:18 +00:00
|
|
|
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(?, ?)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "Adam");
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "96905305");
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
|
|
|
|
|
|
|
|
/* insert another value, using a record and wildcards */
|
|
|
|
query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
|
|
|
|
"VALUES(?, ?, ?)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == TRUE, "file didn't exist after commit\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_msidecomposedesc(void)
|
|
|
|
{
|
2012-08-13 16:18:14 +00:00
|
|
|
UINT (WINAPI *pMsiDecomposeDescriptorA)(LPCSTR, LPCSTR, LPSTR, LPSTR, DWORD *);
|
2007-03-06 11:59:18 +00:00
|
|
|
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;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
hmod = GetModuleHandleA("msi.dll");
|
2012-08-13 16:18:14 +00:00
|
|
|
pMsiDecomposeDescriptorA = (void*)GetProcAddress(hmod, "MsiDecomposeDescriptorA");
|
2007-03-06 11:59:18 +00:00
|
|
|
if (!pMsiDecomposeDescriptorA)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* test a valid feature descriptor */
|
|
|
|
desc = "']gAVn-}f(ZXfeAR6.jiFollowTheWhiteRabbit>3w2x^IGfe?CxI5heAvk.";
|
|
|
|
len = 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 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");
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
|
|
|
|
r = pMsiDecomposeDescriptorA(desc, NULL, NULL, NULL, NULL);
|
|
|
|
ok(r == ERROR_SUCCESS, "returned wrong error\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static UINT try_query_param( MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE hrec )
|
|
|
|
{
|
|
|
|
MSIHANDLE htab = 0;
|
|
|
|
UINT res;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiDatabaseOpenViewA( hdb, szQuery, &htab );
|
2007-03-06 11:59:18 +00:00
|
|
|
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 );
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA( hrec, 1, "Hello");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
r = try_query_param( hdb, szQuery, hrec );
|
|
|
|
|
|
|
|
MsiCloseHandle( hrec );
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_msibadqueries(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb );
|
2007-03-06 11:59:18 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = try_query( hdb, "select * from c");
|
|
|
|
ok(r == ERROR_SUCCESS , "query failed\n");
|
|
|
|
|
|
|
|
r = try_query( hdb, "select * from c where b = 'x");
|
2009-05-17 07:05:22 +00:00
|
|
|
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");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
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 );
|
|
|
|
|
2010-03-01 12:03:29 +00:00
|
|
|
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 );
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
r = MsiCloseHandle( hdb );
|
|
|
|
ok(r == ERROR_SUCCESS , "Failed to close database transact\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = DeleteFileA( msifile );
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == TRUE, "file didn't exist after commit\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_viewmodify(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
UINT r;
|
2008-02-10 13:22:36 +00:00
|
|
|
MSIDBERROR err;
|
2007-03-06 11:59:18 +00:00
|
|
|
const char *query;
|
|
|
|
char buffer[0x100];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
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");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* check what the error function reports without doing anything */
|
|
|
|
sz = 0;
|
|
|
|
/* passing NULL as the 3rd param make function to crash on older platforms */
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( 0, NULL, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* open a view */
|
|
|
|
query = "SELECT * FROM `phone`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
|
|
|
|
/* see what happens with a good hview and bad args */
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, NULL, NULL );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_INVALIDARG || err == MSIDBERROR_NOERROR,
|
|
|
|
"MsiViewGetError returns %u (expected -3)\n", err);
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, buffer, NULL );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_INVALIDARG, "MsiViewGetError return\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* see what happens with a zero length buffer */
|
|
|
|
sz = 0;
|
|
|
|
buffer[0] = 'x';
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, buffer, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_MOREDATA, "MsiViewGetError return\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(buffer[0] == 'x', "buffer cleared\n");
|
|
|
|
ok(sz == 0, "size not zero\n");
|
|
|
|
|
|
|
|
/* ok this one is strange */
|
|
|
|
sz = 0;
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, NULL, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(sz == 0, "size not zero\n");
|
|
|
|
|
|
|
|
/* see if it really has an error */
|
|
|
|
sz = sizeof buffer;
|
|
|
|
buffer[0] = 'x';
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, buffer, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(buffer[0] == 0, "buffer not cleared\n");
|
|
|
|
ok(sz == 0, "size not zero\n");
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
sz = sizeof buffer;
|
|
|
|
buffer[0] = 'x';
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, buffer, &sz );
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(err == MSIDBERROR_NOERROR, "MsiViewGetError return\n");
|
|
|
|
ok(buffer[0] == 0, "buffer not cleared\n");
|
|
|
|
ok(sz == 0, "size not zero\n");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
/* insert a valid record */
|
|
|
|
hrec = MsiCreateRecord(3);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiRecordSetInteger(hrec, 1, 1);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "bob");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "7654321");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
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");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
/* 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;
|
|
|
|
buffer[0] = 'x';
|
2014-04-23 14:49:34 +00:00
|
|
|
err = MsiViewGetErrorA( hview, buffer, &sz );
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(err == MSIDBERROR_DUPLICATEKEY, "MsiViewGetError returned %u\n", err);
|
|
|
|
ok(!strcmp(buffer, "id"), "expected \"id\" c, got \"%s\"\n", buffer);
|
|
|
|
ok(sz == 2, "size not 2\n");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* 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");
|
|
|
|
|
2012-05-14 21:41:45 +00:00
|
|
|
/* 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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "pepe");
|
2012-05-14 21:41:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "7654321");
|
2012-05-14 21:41:45 +00:00
|
|
|
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");
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "SELECT * FROM `phone`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "7654321"), "Expected 7654321, got %s\n", buffer);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
/* update the view, non-primary key */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "3141592");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordSetString failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
/* do it again */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
/* update the view, primary key */
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 5);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordSetInteger failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
r = MsiCloseHandle(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "SELECT * FROM `phone`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "bob"), "Expected bob, got %s\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiRecordGetString failed\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "3141592"), "Expected 3141592, got %s\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "jane");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "112358");
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "jane");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "112358");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "MsiViewModify failed\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "nick");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to set string\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 3, "141421");
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
|
2009-12-22 09:14:17 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
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";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "jerry");
|
2008-02-10 13:22:36 +00:00
|
|
|
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`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "jerry");
|
2008-02-10 13:22:36 +00:00
|
|
|
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;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(msifileW);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
/* create an empty database */
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
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;
|
|
|
|
DWORD sz;
|
|
|
|
char buffer[0x20];
|
|
|
|
|
|
|
|
/* create an empty db */
|
|
|
|
hdb = create_db();
|
|
|
|
ok( hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
/* tables should be present */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, "select * from _Tables", &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
sz = sizeof buffer;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buffer, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get string\n");
|
|
|
|
ok( !strcmp(buffer,"Name"), "_Tables has wrong column name\n");
|
|
|
|
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");
|
|
|
|
sz = sizeof buffer;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buffer, &sz );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get string\n");
|
|
|
|
ok( !strcmp(buffer,"s64"), "_Tables has wrong column type\n");
|
|
|
|
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;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
if( r != ERROR_SUCCESS )
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
if( r == ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
MsiViewGetColumnInfo( hview, type, &rec );
|
|
|
|
}
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
if( r != ERROR_SUCCESS )
|
|
|
|
return r;
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
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 );
|
|
|
|
}
|
|
|
|
}
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL check_record( MSIHANDLE rec, UINT field, LPCSTR val )
|
|
|
|
{
|
|
|
|
CHAR buffer[0x20];
|
|
|
|
UINT r;
|
|
|
|
DWORD sz;
|
|
|
|
|
|
|
|
sz = sizeof buffer;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, field, buffer, &sz );
|
2007-03-06 11:59:18 +00:00
|
|
|
return (r == ERROR_SUCCESS ) && !strcmp(val, buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
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` "
|
2009-05-17 07:05:22 +00:00
|
|
|
"( `Property` CHAR(255), "
|
|
|
|
" `Value` CHAR(1), "
|
|
|
|
" `Intvalue` INT, "
|
|
|
|
" `Integervalue` INTEGER, "
|
|
|
|
" `Shortvalue` SHORT, "
|
|
|
|
" `Longvalue` LONG, "
|
|
|
|
" `Longcharvalue` LONGCHAR "
|
|
|
|
" PRIMARY KEY `Property`)" );
|
2007-03-06 11:59:18 +00:00
|
|
|
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" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "S255"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "S1"), "wrong record type\n");
|
2009-05-17 07:05:22 +00:00
|
|
|
ok( check_record( rec, 3, "I2"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 4, "I2"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 5, "I2"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 6, "I4"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 7, "S0"), "wrong record type\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
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");
|
2009-05-17 07:05:22 +00:00
|
|
|
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");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* now try the names */
|
|
|
|
rec = get_column_info( hdb, "select * from `Properties`", MSICOLINFO_NAMES );
|
|
|
|
ok( rec, "failed to get column info record\n" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "Property"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "Value"), "wrong record type\n");
|
2009-05-17 07:05:22 +00:00
|
|
|
ok( check_record( rec, 3, "Intvalue"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 4, "Integervalue"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 5, "Shortvalue"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 6, "Longvalue"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 7, "Longcharvalue"), "wrong record type\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
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" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "S255"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "V0"), "wrong record type\n");
|
|
|
|
|
|
|
|
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" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "Name"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "Data"), "wrong record type\n");
|
|
|
|
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" );
|
|
|
|
ok( check_record( rec, 1, "Key"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "Text"), "wrong record type\n");
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
rec = get_column_info( hdb, "select * from `UIText`", MSICOLINFO_TYPES );
|
|
|
|
ok( rec, "failed to get column info record\n" );
|
|
|
|
ok( check_record( rec, 1, "s72"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "L255"), "wrong record type\n");
|
|
|
|
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";
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(msifileW);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
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`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
GetCurrentDirectoryA(MAX_PATH, path);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseExportA(hdb, "phone", path, file);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseExport failed\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
lstrcatA(path, "\\");
|
|
|
|
lstrcatA(path, file);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* check the data that was written */
|
|
|
|
length = 0;
|
|
|
|
memset(buffer, 0, sizeof buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
handle = CreateFileA(path, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
|
2007-03-06 11:59:18 +00:00
|
|
|
if (handle != INVALID_HANDLE_VALUE)
|
|
|
|
{
|
|
|
|
ReadFile(handle, buffer, sizeof buffer, &length, NULL);
|
|
|
|
CloseHandle(handle);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(path);
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
ok(0, "failed to open file %s\n", path);
|
|
|
|
|
|
|
|
ok( length == strlen(expected), "length of data wrong\n");
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(buffer, expected), "data doesn't match\n");
|
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_longstrings(void)
|
|
|
|
{
|
2008-02-10 13:22:36 +00:00
|
|
|
const char insert_query[] =
|
2007-03-06 11:59:18 +00:00
|
|
|
"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;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(msifileW);
|
2007-03-06 11:59:18 +00:00
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
/* create a table */
|
2008-02-10 13:22:36 +00:00
|
|
|
r = try_query( hdb,
|
2007-03-06 11:59:18 +00:00
|
|
|
"CREATE TABLE `strings` ( `id` INT, `val` CHAR(0) PRIMARY KEY `id`)");
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
/* try to insert a very long string */
|
2007-03-06 11:59:18 +00:00
|
|
|
str = HeapAlloc(GetProcessHeap(), 0, 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");
|
|
|
|
|
|
|
|
HeapFree(GetProcessHeap(), 0, str);
|
|
|
|
|
2012-08-13 16:18:14 +00:00
|
|
|
r = MsiDatabaseCommit(hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, "select * from `strings` where `id` = 1", &hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
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");
|
|
|
|
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, NULL, &len);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
ok(len == STRING_LENGTH, "string length wrong\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiCloseHandle(hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|
2007-10-19 23:01:40 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
static void create_file_data(LPCSTR name, LPCSTR data, DWORD size)
|
2008-02-10 13:22:36 +00:00
|
|
|
{
|
|
|
|
HANDLE file;
|
|
|
|
DWORD written;
|
|
|
|
|
|
|
|
file = CreateFileA(name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL);
|
2008-12-28 10:25:32 +00:00
|
|
|
if (file == INVALID_HANDLE_VALUE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
WriteFile(file, data, strlen(data), &written, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
WriteFile(file, "\n", strlen("\n"), &written, NULL);
|
2008-12-28 10:25:32 +00:00
|
|
|
|
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
SetFilePointer(file, size, NULL, FILE_BEGIN);
|
|
|
|
SetEndOfFile(file);
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
CloseHandle(file);
|
|
|
|
}
|
2008-12-28 10:25:32 +00:00
|
|
|
|
|
|
|
#define create_file(name) create_file_data(name, name, 0)
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
static void test_streamtable(void)
|
|
|
|
{
|
2010-03-01 12:03:29 +00:00
|
|
|
MSIHANDLE hdb = 0, rec, view, hsi;
|
2008-02-10 13:22:36 +00:00
|
|
|
char file[MAX_PATH];
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
DWORD size;
|
2007-03-06 11:59:18 +00:00
|
|
|
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" );
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
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 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "Failed to open database\n" );
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* check the column types */
|
|
|
|
rec = get_column_info( hdb, "select * from `_Streams`", MSICOLINFO_TYPES );
|
|
|
|
ok( rec, "failed to get column info record\n" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "s62"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "V0"), "wrong record type\n");
|
|
|
|
|
|
|
|
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" );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "Name"), "wrong record type\n");
|
|
|
|
ok( check_record( rec, 2, "Data"), "wrong record type\n");
|
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-03-01 12:03:29 +00:00
|
|
|
"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 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-03-01 12:03:29 +00:00
|
|
|
"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 );
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
/* insert a file into the _Streams table */
|
|
|
|
create_file( "test.txt" );
|
|
|
|
|
|
|
|
rec = MsiCreateRecord( 2 );
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA( rec, 1, "data" );
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA( rec, 2, "test.txt" );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA("test.txt");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2008-02-10 13:22:36 +00:00
|
|
|
"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 );
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose( view );
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
2010-02-06 21:29:15 +00:00
|
|
|
/* insert another one */
|
|
|
|
create_file( "test1.txt" );
|
|
|
|
|
|
|
|
rec = MsiCreateRecord( 2 );
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA( rec, 1, "data1" );
|
2010-02-06 21:29:15 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA( rec, 2, "test1.txt" );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA("test1.txt");
|
2010-02-06 21:29:15 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-02-06 21:29:15 +00:00
|
|
|
"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 );
|
|
|
|
|
2015-03-09 20:28:54 +00:00
|
|
|
/* try again */
|
|
|
|
create_file( "test1.txt" );
|
|
|
|
|
|
|
|
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 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-02-06 21:29:15 +00:00
|
|
|
"SELECT `Name`, `Data` FROM `_Streams` WHERE `Name` = 'data'", &view );
|
2008-02-10 13:22:36 +00:00
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, file, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(file, "data"), "Expected 'data', got %s\n", file);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
2010-02-06 21:29:15 +00:00
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-02-06 21:29:15 +00:00
|
|
|
"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);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, file, &size );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2010-02-06 21:29:15 +00:00
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(buf, "test1.txt\n"), "Expected 'test1.txt\\n', got %s\n", buf);
|
2010-02-06 21:29:15 +00:00
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
|
|
|
/* perform an update */
|
|
|
|
create_file( "test2.txt" );
|
|
|
|
rec = MsiCreateRecord( 1 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA( rec, 1, "test2.txt" );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA("test2.txt");
|
2010-02-06 21:29:15 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-02-06 21:29:15 +00:00
|
|
|
"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 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb,
|
2010-02-06 21:29:15 +00:00
|
|
|
"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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, file, &size );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(file, "data1"), "Expected 'data1', got %s\n", file);
|
2010-02-06 21:29:15 +00:00
|
|
|
|
|
|
|
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);
|
2015-03-09 20:28:54 +00:00
|
|
|
ok( !lstrcmpA(buf, "test2.txt\n"), "Expected 'test2.txt\\n', got %s\n", buf);
|
2010-02-06 21:29:15 +00:00
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose( view );
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle( view );
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiCloseHandle( hdb );
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb );
|
2009-06-06 15:59:11 +00:00
|
|
|
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" );
|
|
|
|
rec = MsiCreateRecord( 1 );
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA( rec, 1, "test.txt" );
|
2009-06-06 15:59:11 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to add stream data to the record: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA( "test.txt" );
|
2009-06-06 15:59:11 +00:00
|
|
|
|
2015-03-09 20:28:54 +00:00
|
|
|
/* 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" );
|
|
|
|
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" );
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
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 );
|
|
|
|
|
2015-03-09 20:28:54 +00:00
|
|
|
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 );
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_READONLY, &hdb );
|
2009-06-06 15:59:11 +00:00
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, file, &size );
|
2009-06-06 15:59:11 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(file, "Binary.filename1.1"), "Expected 'Binary.filename1.1', got %s\n", file );
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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 );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, file, &size );
|
2009-06-06 15:59:11 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "Failed to get string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file );
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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 );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA(buf, "test.txt\n"), "Expected 'test.txt\\n', got %s\n", buf );
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA( msifile );
|
2009-06-06 15:59:11 +00:00
|
|
|
}
|
|
|
|
|
2009-11-16 01:15:54 +00:00
|
|
|
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";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-11-16 01:15:54 +00:00
|
|
|
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 );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "cond2"), "wrong condition\n");
|
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
|
|
|
|
|
|
|
|
ok( check_record( rec, 1, "cond3"), "wrong condition\n");
|
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
MsiCloseHandle( hdb );
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2009-11-16 01:15:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
static void test_where(void)
|
|
|
|
{
|
2008-02-10 13:22:36 +00:00
|
|
|
MSIHANDLE hdb = 0, rec, view;
|
2007-03-06 11:59:18 +00:00
|
|
|
LPCSTR query;
|
|
|
|
UINT r;
|
2008-02-10 13:22:36 +00:00
|
|
|
DWORD size;
|
|
|
|
CHAR buf[MAX_PATH];
|
|
|
|
UINT count;
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
ok( check_record( rec, 4, "zero.cab"), "wrong cabinet\n");
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Media` WHERE `LastSequence` >= 1";
|
|
|
|
r = do_query(hdb, query, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed: %d\n", r);
|
|
|
|
ok( check_record( rec, 4, "one.cab"), "wrong cabinet\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok( 2 == r, "field wrong\n");
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok( 1 == r, "field wrong\n");
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= 1 AND DiskId >= 0";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewExecute(view, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount( rec );
|
|
|
|
ok( count == 1, "Expected 1 record fields, got %d\n", count );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA( buf, "2" ), "For (row %d, column 1) expected '%d', got %s\n", 0, 2, buf );
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle( rec );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( rec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA( buf, "3" ), "For (row %d, column 1) expected '%d', got %s\n", 1, 3, buf );
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle( rec );
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
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 );
|
|
|
|
|
2009-12-22 09:14:17 +00:00
|
|
|
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);
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "query failed: %d\n", r );
|
2009-12-22 09:14:17 +00:00
|
|
|
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 );
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
rec = MsiCreateRecord(1);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "SELECT * FROM `Media` WHERE `DiskPrompt` = ?";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 );
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static CHAR CURR_DIR[MAX_PATH];
|
|
|
|
|
|
|
|
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";
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
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"
|
2012-01-21 17:21:57 +00:00
|
|
|
"7\tIntel;1033,2057\n"
|
2009-06-06 15:59:11 +00:00
|
|
|
"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";
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static void write_file(const CHAR *filename, const char *data, int data_size)
|
|
|
|
{
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
HANDLE hf = CreateFileA(filename, GENERIC_WRITE, 0, NULL,
|
|
|
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
WriteFile(hf, data, data_size, &size, NULL);
|
|
|
|
CloseHandle(hf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static UINT add_table_to_db(MSIHANDLE hdb, LPCSTR table_data)
|
|
|
|
{
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
write_file("temp_file", table_data, (lstrlenA(table_data) - 1) * sizeof(char));
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiDatabaseImportA(hdb, CURR_DIR, "temp_file");
|
|
|
|
DeleteFileA("temp_file");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
static void test_suminfo_import(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hsi, view = 0;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT r, count, size, type;
|
|
|
|
char str_value[50];
|
|
|
|
INT int_value;
|
|
|
|
FILETIME ft_value;
|
|
|
|
|
|
|
|
GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2009-06-06 15:59:11 +00:00
|
|
|
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 %u\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);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(!strcmp(str_value, "Intel;1033,2057"),
|
|
|
|
"Expected \"Intel;1033,2057\", got %s\n", str_value);
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
static void test_msiimport(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, view, rec;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT r, count;
|
|
|
|
signed int i;
|
|
|
|
|
|
|
|
GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2007-03-06 11:59:18 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = add_table_to_db(hdb, test_data);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = add_table_to_db(hdb, endlines2);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "SELECT * FROM `TestTable`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 9, "Expected 9, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "FirstPrimaryColumn"), "Expected FirstPrimaryColumn\n");
|
|
|
|
ok(check_record(rec, 2, "SecondPrimaryColumn"), "Expected SecondPrimaryColumn\n");
|
|
|
|
ok(check_record(rec, 3, "ShortInt"), "Expected ShortInt\n");
|
|
|
|
ok(check_record(rec, 4, "ShortIntNullable"), "Expected ShortIntNullalble\n");
|
|
|
|
ok(check_record(rec, 5, "LongInt"), "Expected LongInt\n");
|
|
|
|
ok(check_record(rec, 6, "LongIntNullable"), "Expected LongIntNullalble\n");
|
|
|
|
ok(check_record(rec, 7, "String"), "Expected String\n");
|
|
|
|
ok(check_record(rec, 8, "LocalizableString"), "Expected LocalizableString\n");
|
|
|
|
ok(check_record(rec, 9, "LocalizableStringNullable"), "Expected LocalizableStringNullable\n");
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 9, "Expected 9, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "s255"), "Expected s255\n");
|
|
|
|
ok(check_record(rec, 2, "i2"), "Expected i2\n");
|
|
|
|
ok(check_record(rec, 3, "i2"), "Expected i2\n");
|
|
|
|
ok(check_record(rec, 4, "I2"), "Expected I2\n");
|
|
|
|
ok(check_record(rec, 5, "i4"), "Expected i4\n");
|
|
|
|
ok(check_record(rec, 6, "I4"), "Expected I4\n");
|
|
|
|
ok(check_record(rec, 7, "S255"), "Expected S255\n");
|
|
|
|
ok(check_record(rec, 8, "S0"), "Expected S0\n");
|
|
|
|
ok(check_record(rec, 9, "s0"), "Expected s0\n");
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
query = "SELECT * FROM `TestTable`";
|
2008-02-10 13:22:36 +00:00
|
|
|
r = do_query(hdb, query, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(check_record(rec, 1, "stringage"), "Expected 'stringage'\n");
|
|
|
|
ok(check_record(rec, 7, "another string"), "Expected 'another string'\n");
|
|
|
|
ok(check_record(rec, 8, "localizable"), "Expected 'localizable'\n");
|
|
|
|
ok(check_record(rec, 9, "duh"), "Expected 'duh'\n");
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(i == 5, "Expected 5, got %d\n", i);
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 3);
|
|
|
|
ok(i == 2, "Expected 2, got %d\n", i);
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 4);
|
|
|
|
ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 5);
|
|
|
|
ok(i == 2147483640, "Expected 2147483640, got %d\n", i);
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 6);
|
|
|
|
ok(i == -2147483640, "Expected -2147483640, got %d\n", i);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(view);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `TwoPrimary`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 2, "Expected 2, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "PrimaryOne"), "Expected PrimaryOne\n");
|
|
|
|
ok(check_record(rec, 2, "PrimaryTwo"), "Expected PrimaryTwo\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 2, "Expected 2, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "s255"), "Expected s255\n");
|
|
|
|
ok(check_record(rec, 2, "s255"), "Expected s255\n");
|
|
|
|
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);
|
|
|
|
|
|
|
|
ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
|
|
|
|
ok(check_record(rec, 2, "leaf"), "Expected 'leaf'\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
ok(check_record(rec, 1, "papaya"), "Expected 'papaya'\n");
|
|
|
|
ok(check_record(rec, 2, "flower"), "Expected 'flower'\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS,
|
|
|
|
"Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(count == 6, "Expected 6, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "A"), "Expected A\n");
|
|
|
|
ok(check_record(rec, 2, "B"), "Expected B\n");
|
|
|
|
ok(check_record(rec, 3, "C"), "Expected C\n");
|
|
|
|
ok(check_record(rec, 4, "D"), "Expected D\n");
|
|
|
|
ok(check_record(rec, 5, "E"), "Expected E\n");
|
|
|
|
ok(check_record(rec, 6, "F"), "Expected F\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(count == 6, "Expected 6, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "s72"), "Expected s72\n");
|
|
|
|
ok(check_record(rec, 2, "s72"), "Expected s72\n");
|
|
|
|
ok(check_record(rec, 3, "s72"), "Expected s72\n");
|
|
|
|
ok(check_record(rec, 4, "s72"), "Expected s72\n");
|
|
|
|
ok(check_record(rec, 5, "s72"), "Expected s72\n");
|
|
|
|
ok(check_record(rec, 6, "s72"), "Expected s72\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewExecute(view, 0);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(view, &rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(check_record(rec, 1, "a"), "Expected 'a'\n");
|
|
|
|
ok(check_record(rec, 2, "b"), "Expected 'b'\n");
|
|
|
|
ok(check_record(rec, 3, "c"), "Expected 'c'\n");
|
|
|
|
ok(check_record(rec, 4, "d"), "Expected 'd'\n");
|
|
|
|
ok(check_record(rec, 5, "e"), "Expected 'e'\n");
|
|
|
|
ok(check_record(rec, 6, "f"), "Expected 'f'\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiViewFetch(view, &rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(check_record(rec, 1, "g"), "Expected 'g'\n");
|
|
|
|
ok(check_record(rec, 2, "h"), "Expected 'h'\n");
|
|
|
|
ok(check_record(rec, 3, "i"), "Expected 'i'\n");
|
|
|
|
ok(check_record(rec, 4, "j"), "Expected 'j'\n");
|
|
|
|
ok(check_record(rec, 5, "k"), "Expected 'k'\n");
|
|
|
|
ok(check_record(rec, 6, "l"), "Expected 'l'\n");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS,
|
|
|
|
"Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiViewClose(view);
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiCloseHandle(view);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
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));
|
2014-04-23 14:49:34 +00:00
|
|
|
CreateDirectoryA("bin_import", NULL);
|
2009-06-06 15:59:11 +00:00
|
|
|
create_file_data("bin_import/filename1.ibd", "just some words", 15);
|
|
|
|
|
|
|
|
/* import files into database */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2009-06-06 15:59:11 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "Failed to open database\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
GetCurrentDirectoryA(MAX_PATH, path);
|
|
|
|
r = MsiDatabaseImportA(hdb, path, "bin_import.idt");
|
2009-06-06 15:59:11 +00:00
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, file, &size);
|
2009-06-06 15:59:11 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(file, "filename1"), "Expected 'filename1', got %s\n", file);
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "just some words"), "Expected 'just some words', got %s\n", buf);
|
2009-06-06 15:59:11 +00:00
|
|
|
|
|
|
|
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");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA("bin_import/filename1.ibd");
|
|
|
|
RemoveDirectoryA("bin_import");
|
|
|
|
DeleteFileA("bin_import.idt");
|
2009-06-06 15:59:11 +00:00
|
|
|
}
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Table");
|
|
|
|
MsiRecordSetStringA(rec, 2, "Apples");
|
|
|
|
MsiRecordSetStringA(rec, 3, "Oranges");
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* 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);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Fable");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
/* 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);
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* try table name as marker without backticks */
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Mable");
|
2007-03-06 11:59:18 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try column names as markers */
|
|
|
|
rec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
|
|
|
MsiRecordSetStringA(rec, 2, "Two");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try names with backticks */
|
|
|
|
rec = MsiCreateRecord(3);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
|
|
|
MsiRecordSetStringA(rec, 2, "Two");
|
|
|
|
MsiRecordSetStringA(rec, 3, "One");
|
2007-03-06 11:59:18 +00:00
|
|
|
query = "CREATE TABLE `Mable` ( `?` SHORT NOT NULL, `?` CHAR(255) PRIMARY KEY `?`)";
|
|
|
|
r = run_query(hdb, rec, query);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* 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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try one long marker */
|
|
|
|
rec = MsiCreateRecord(1);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "`One` SHORT NOT NULL, `Two` CHAR(255) PRIMARY KEY `One`");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try all names as markers */
|
|
|
|
rec = MsiCreateRecord(4);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Mable");
|
|
|
|
MsiRecordSetStringA(rec, 2, "One");
|
|
|
|
MsiRecordSetStringA(rec, 3, "Two");
|
|
|
|
MsiRecordSetStringA(rec, 4, "One");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = try_query(hdb, "SELECT * from `Table`");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
/* try values as markers */
|
|
|
|
rec = MsiCreateRecord(2);
|
|
|
|
MsiRecordSetInteger(rec, 1, 4);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 2, "hi");
|
2007-03-06 11:59:18 +00:00
|
|
|
query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
|
|
|
|
r = run_query(hdb, rec, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try column names and values as markers */
|
|
|
|
rec = MsiCreateRecord(4);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
|
|
|
MsiRecordSetStringA(rec, 2, "Two");
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiRecordSetInteger(rec, 3, 5);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 4, "hi");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try column names as markers */
|
|
|
|
rec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
|
|
|
MsiRecordSetStringA(rec, 2, "Two");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try table name as a marker */
|
|
|
|
rec = MsiCreateRecord(1);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Table");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try table name and values as markers */
|
|
|
|
rec = MsiCreateRecord(3);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Table");
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiRecordSetInteger(rec, 2, 10);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 3, "haha");
|
2007-03-06 11:59:18 +00:00
|
|
|
query = "INSERT INTO `?` ( `One`, `Two` ) VALUES ( ?, '?' )";
|
|
|
|
r = run_query(hdb, rec, query);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* try all markers */
|
|
|
|
rec = MsiCreateRecord(5);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "Table");
|
|
|
|
MsiRecordSetStringA(rec, 1, "One");
|
|
|
|
MsiRecordSetStringA(rec, 1, "Two");
|
2007-03-06 11:59:18 +00:00
|
|
|
MsiRecordSetInteger(rec, 2, 10);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 3, "haha");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* insert an integer as a string */
|
|
|
|
rec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "11");
|
|
|
|
MsiRecordSetStringA(rec, 2, "hi");
|
2007-03-06 11:59:18 +00:00
|
|
|
query = "INSERT INTO `Table` ( `One`, `Two` ) VALUES ( ?, '?' )";
|
|
|
|
r = run_query(hdb, rec, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(rec);
|
2007-03-06 11:59:18 +00:00
|
|
|
|
|
|
|
/* leave off the '' for the string */
|
|
|
|
rec = MsiCreateRecord(2);
|
|
|
|
MsiRecordSetInteger(rec, 1, 12);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 2, "hi");
|
2007-03-06 11:59:18 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
#define MY_NVIEWS 4000 /* Largest installer I've seen uses < 2k */
|
|
|
|
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;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, szQueryBuf, &hviews[i]);
|
2008-02-10 13:22:36 +00:00
|
|
|
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) {
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hviews[i]);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 */
|
2014-04-23 14:49:34 +00:00
|
|
|
CopyFileA(msifile2, msifile, FALSE);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb1 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "Failed to create database\n" );
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit( hdb1 );
|
|
|
|
ok( r == ERROR_SUCCESS , "Failed to commit database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifile2W, MSIDBOPEN_READONLY, &hdb2 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "Failed to create database\n" );
|
|
|
|
|
|
|
|
/* the transform between two identical database should be empty */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseGenerateTransformA(hdb1, hdb2, NULL, 0, 0);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseGenerateTransformA(hdb1, hdb2, mstfile, 0, 0);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
|
|
|
|
|
|
|
|
MsiCloseHandle( hdb1 );
|
|
|
|
MsiCloseHandle( hdb2 );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA("testdata.bin");
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 },
|
|
|
|
};
|
|
|
|
|
|
|
|
#define NUM_TRANSFORM_TABLES (sizeof table_transform_data/sizeof table_transform_data[0])
|
|
|
|
|
|
|
|
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<NUM_TRANSFORM_TABLES; 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 %08x\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;
|
|
|
|
|
2008-05-09 17:35:45 +00:00
|
|
|
/* build summary info */
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiGetSummaryInformationA(hdb, NULL, 7, &suminfo);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to open summaryinfo\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo,2, VT_LPSTR, 0,NULL,
|
2008-02-10 13:22:36 +00:00
|
|
|
"Installation Database");
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo,3, VT_LPSTR, 0,NULL,
|
2008-02-10 13:22:36 +00:00
|
|
|
"Installation Database");
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo,4, VT_LPSTR, 0,NULL,
|
2008-02-10 13:22:36 +00:00
|
|
|
"Wine Hackers");
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo,7, VT_LPSTR, 0,NULL,
|
2012-01-21 17:21:57 +00:00
|
|
|
";1033,2057");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo,9, VT_LPSTR, 0,NULL,
|
2008-02-10 13:22:36 +00:00
|
|
|
"{913B8D18-FBB6-4CAC-A239-C74C11E3FA74}");
|
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo, 14, VT_I4, 100, NULL, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiSummaryInfoSetPropertyA(suminfo, 15, VT_I4, 0, NULL, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
static MSIHANDLE create_package_db(const WCHAR *filename)
|
2008-02-10 13:22:36 +00:00
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0;
|
|
|
|
UINT res;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(msifileW);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
/* create an empty database */
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW(filename, MSIDBOPEN_CREATE, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to set summary info\n" );
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
res = create_directory_table(hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( res == ERROR_SUCCESS , "Failed to create directory table\n" );
|
|
|
|
|
|
|
|
return hdb;
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
static UINT package_from_db(MSIHANDLE hdb, MSIHANDLE *handle)
|
2008-02-10 13:22:36 +00:00
|
|
|
{
|
|
|
|
UINT res;
|
2012-01-21 17:21:57 +00:00
|
|
|
CHAR szPackage[12];
|
2008-02-10 13:22:36 +00:00
|
|
|
MSIHANDLE hPackage;
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
sprintf(szPackage, "#%u", hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenPackageA(szPackage, &hPackage);
|
2008-02-10 13:22:36 +00:00
|
|
|
if (res != ERROR_SUCCESS)
|
2012-01-21 17:21:57 +00:00
|
|
|
return res;
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
res = MsiCloseHandle(hdb);
|
|
|
|
if (res != ERROR_SUCCESS)
|
2012-01-21 17:21:57 +00:00
|
|
|
{
|
|
|
|
MsiCloseHandle(hPackage);
|
|
|
|
return res;
|
|
|
|
}
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
*handle = hPackage;
|
|
|
|
return ERROR_SUCCESS;
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_try_transform(void)
|
|
|
|
{
|
2012-01-21 17:21:57 +00:00
|
|
|
MSIHANDLE hdb, hview, hrec, hpkg = 0;
|
2008-02-10 13:22:36 +00:00
|
|
|
LPCSTR query;
|
|
|
|
UINT r;
|
|
|
|
DWORD sz;
|
|
|
|
char buffer[MAX_PATH];
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
|
|
|
DeleteFileA(mstfile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
/* create the database */
|
2014-04-23 14:49:34 +00:00
|
|
|
hdb = create_package_db(msifileW);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA(hrec, 2, "testdata.bin");
|
2008-02-10 13:22:36 +00:00
|
|
|
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();
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "Failed to create database\n" );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseApplyTransformA( hdb, mstfile, 0 );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "return code %d, should be ERROR_SUCCESS\n", r );
|
|
|
|
|
|
|
|
MsiDatabaseCommit( hdb );
|
|
|
|
|
|
|
|
/* 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`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof buffer;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "record get string failed\n");
|
|
|
|
ok(!lstrcmpA(buffer, "c"), "Expected c, got %s\n", buffer);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 3);
|
|
|
|
ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 4);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "view fetch failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof buffer;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "record get string failed\n");
|
|
|
|
ok(!lstrcmpA(buffer, "b"), "Expected b, got %s\n", buffer);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 3);
|
|
|
|
ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 4);
|
|
|
|
ok(r == 0x80000000, "Expected 0x80000000, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "view fetch succeeded\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
/* check that the property was added */
|
2012-01-21 17:21:57 +00:00
|
|
|
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);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
sz = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "prop", buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "val"), "Expected val, got %s\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hpkg);
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
error:
|
|
|
|
MsiCloseHandle(hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
|
|
|
DeleteFileA(mstfile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct join_res
|
|
|
|
{
|
|
|
|
const CHAR one[MAX_PATH];
|
|
|
|
const CHAR two[MAX_PATH];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct join_res_4col
|
|
|
|
{
|
|
|
|
const CHAR one[MAX_PATH];
|
|
|
|
const CHAR two[MAX_PATH];
|
|
|
|
const CHAR three[MAX_PATH];
|
|
|
|
const CHAR four[MAX_PATH];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct join_res_uint
|
|
|
|
{
|
|
|
|
UINT one;
|
|
|
|
UINT two;
|
|
|
|
UINT three;
|
|
|
|
UINT four;
|
|
|
|
UINT five;
|
|
|
|
UINT six;
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_first[] =
|
|
|
|
{
|
|
|
|
{ "alveolar", "procerus" },
|
|
|
|
{ "septum", "procerus" },
|
|
|
|
{ "septum", "nasalis" },
|
|
|
|
{ "ramus", "nasalis" },
|
|
|
|
{ "malar", "mentalis" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_second[] =
|
|
|
|
{
|
|
|
|
{ "nasal", "septum" },
|
|
|
|
{ "mandible", "ramus" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_third[] =
|
|
|
|
{
|
|
|
|
{ "msvcp.dll", "abcdefgh" },
|
|
|
|
{ "msvcr.dll", "ijklmnop" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_fourth[] =
|
|
|
|
{
|
|
|
|
{ "msvcp.dll.01234", "single.dll.31415" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_fifth[] =
|
|
|
|
{
|
|
|
|
{ "malar", "procerus" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_sixth[] =
|
|
|
|
{
|
|
|
|
{ "malar", "procerus" },
|
|
|
|
{ "malar", "procerus" },
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
{ "malar", "mentalis" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res join_res_seventh[] =
|
|
|
|
{
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
{ "malar", "nasalis" },
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct join_res_4col join_res_eighth[] =
|
|
|
|
{
|
|
|
|
{ "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 struct join_res_uint join_res_ninth[] =
|
|
|
|
{
|
|
|
|
{ 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;
|
|
|
|
CHAR buf[MAX_PATH];
|
|
|
|
UINT r, count;
|
|
|
|
DWORD size, i;
|
|
|
|
BOOL data_correct;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok( hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
r = create_component_table( hdb );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot create Component table: %d\n", r );
|
|
|
|
|
|
|
|
r = add_component_entry( hdb, "'zygomatic', 'malar', 'INSTALLDIR', 0, '', ''" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
|
|
|
|
|
|
|
|
r = add_component_entry( hdb, "'maxilla', 'alveolar', 'INSTALLDIR', 0, '', ''" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
|
|
|
|
|
|
|
|
r = add_component_entry( hdb, "'nasal', 'septum', 'INSTALLDIR', 0, '', ''" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
|
|
|
|
|
|
|
|
r = add_component_entry( hdb, "'mandible', 'ramus', 'INSTALLDIR', 0, '', ''" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add component: %d\n", r );
|
|
|
|
|
|
|
|
r = create_feature_components_table( hdb );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot create FeatureComponents table: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'procerus', 'maxilla'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'procerus', 'nasal'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'nasalis', 'nasal'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'nasalis', 'mandible'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'nasalis', 'notacomponent'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = add_feature_components_entry( hdb, "'mentalis', 'zygomatic'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add feature components: %d\n", r );
|
|
|
|
|
|
|
|
r = create_std_dlls_table( hdb );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot create StdDlls table: %d\n", r );
|
|
|
|
|
|
|
|
r = add_std_dlls_entry( hdb, "'msvcp.dll', 'msvcp.dll.01234'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
|
|
|
|
|
|
|
|
r = add_std_dlls_entry( hdb, "'msvcr.dll', 'msvcr.dll.56789'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add std dlls: %d\n", r );
|
|
|
|
|
|
|
|
r = create_binary_table( hdb );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot create Binary table: %d\n", r );
|
|
|
|
|
|
|
|
r = add_binary_entry( hdb, "'msvcp.dll.01234', 'abcdefgh'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
|
|
|
|
|
|
|
|
r = add_binary_entry( hdb, "'msvcr.dll.56789', 'ijklmnop'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
|
|
|
|
|
|
|
|
r = add_binary_entry( hdb, "'single.dll.31415', 'msvcp.dll'" );
|
|
|
|
ok( r == ERROR_SUCCESS, "cannot add binary: %d\n", r );
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` (`A` SHORT, `B` SHORT PRIMARY KEY `A`)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Two` (`C` SHORT, `D` SHORT PRIMARY KEY `C`)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Three` (`E` SHORT, `F` SHORT PRIMARY KEY `E`)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` (`A`, `B`) VALUES (1, 2)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Two` (`C`, `D`) VALUES (3, 4)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Two` (`C`, `D`) VALUES (5, 6)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Three` (`E`, `F`) VALUES (7, 8)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Three` (`E`, `F`) VALUES (9, 10)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Three` (`E`, `F`) VALUES (11, 12)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` (`G` SHORT, `H` SHORT PRIMARY KEY `G`)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Five` (`I` SHORT, `J` SHORT PRIMARY KEY `I`)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Five` (`I`, `J`) VALUES (13, 14)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "INSERT INTO `Five` (`I`, `J`) VALUES (15, 16)";
|
|
|
|
r = run_query( hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot insert into table: %d\n", r );
|
|
|
|
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` "
|
|
|
|
"WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
|
|
|
|
"ORDER BY `Feature_`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA( buf, join_res_first[i].one ),
|
2008-02-10 13:22:36 +00:00
|
|
|
"For (row %d, column 1) expected '%s', got %s\n", i, join_res_first[i].one, buf );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA( buf, join_res_first[i].two ),
|
2008-02-10 13:22:36 +00:00
|
|
|
"For (row %d, column 2) expected '%s', got %s\n", i, join_res_first[i].two, buf );
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
|
|
|
|
ok( i == 5, "Expected 5 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
/* try a join without a WHERE condition */
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` ";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( i == 24, "Expected 24 rows, got %d\n", i );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT DISTINCT Component, ComponentId FROM FeatureComponents, Component "
|
|
|
|
"WHERE FeatureComponents.Component_=Component.Component "
|
|
|
|
"AND (Feature_='nasalis') ORDER BY Feature_";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_second[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_second[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 2, "Expected 2 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
|
|
|
|
"FROM `StdDlls`, `Binary` "
|
|
|
|
"WHERE `StdDlls`.`Binary_` = `Binary`.`Name` "
|
|
|
|
"ORDER BY `File`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_third[i].one ) )
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_third[i].two ) )
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 2, "Expected 2 rows, got %d\n", i );
|
|
|
|
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `StdDlls`.`Binary_`, `Binary`.`Name` "
|
|
|
|
"FROM `StdDlls`, `Binary` "
|
|
|
|
"WHERE `StdDlls`.`File` = `Binary`.`Data` "
|
|
|
|
"ORDER BY `Name`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_fourth[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_fourth[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 1, "Expected 1 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` "
|
|
|
|
"WHERE `Component`.`Component` = 'zygomatic' "
|
|
|
|
"AND `FeatureComponents`.`Component_` = 'maxilla' "
|
|
|
|
"ORDER BY `Feature_`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_fifth[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_fifth[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 1, "Expected 1 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` "
|
|
|
|
"WHERE `Component` = 'zygomatic' "
|
|
|
|
"ORDER BY `Feature_`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_sixth[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_sixth[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 6, "Expected 6 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` "
|
|
|
|
"WHERE `Component` = 'zygomatic' "
|
|
|
|
"AND `Feature_` = 'nasalis' "
|
|
|
|
"ORDER BY `Feature_`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_seventh[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_seventh[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
ok( i == 3, "Expected 3 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `StdDlls`.`File`, `Binary`.`Data` "
|
|
|
|
"FROM `StdDlls`, `Binary` ";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 2, "Expected 2 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].four ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
ok( i == 6, "Expected 6 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `StdDlls`, `Binary` ";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 4, "Expected 4 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].one ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 2, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].two ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 3, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].three ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 4, buf, &size );
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
if( lstrcmpA( buf, join_res_eighth[i].four ))
|
2008-02-10 13:22:36 +00:00
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 6, "Expected 6 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`, `Two`, `Three` ";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
data_correct = TRUE;
|
|
|
|
while ((r = MsiViewFetch(hview, &hrec)) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
count = MsiRecordGetFieldCount( hrec );
|
|
|
|
ok( count == 6, "Expected 6 record fields, got %d\n", count );
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 1 );
|
|
|
|
if( r != join_res_ninth[i].one )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 2 );
|
|
|
|
if( r != join_res_ninth[i].two )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 3 );
|
|
|
|
if( r != join_res_ninth[i].three )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 4 );
|
|
|
|
if( r != join_res_ninth[i].four )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 5 );
|
|
|
|
if( r != join_res_ninth[i].five )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger( hrec, 6);
|
|
|
|
if( r != join_res_ninth[i].six )
|
|
|
|
data_correct = FALSE;
|
|
|
|
|
|
|
|
i++;
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
}
|
|
|
|
ok( data_correct, "data returned in the wrong order\n");
|
|
|
|
|
|
|
|
ok( i == 6, "Expected 6 rows, got %d\n", i );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "expected no more items: %d\n", r );
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Four`, `Five`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2008-04-04 16:43:16 +00:00
|
|
|
query = "SELECT * FROM `Nonexistent`, `One`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r );
|
|
|
|
|
2010-02-06 21:29:15 +00:00
|
|
|
/* try updating a row in a join table */
|
|
|
|
query = "SELECT `Component`.`ComponentId`, `FeatureComponents`.`Feature_` "
|
|
|
|
"FROM `Component`, `FeatureComponents` "
|
|
|
|
"WHERE `Component`.`Component` = `FeatureComponents`.`Component_` "
|
|
|
|
"ORDER BY `Feature_`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to execute view: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to fetch view: %d\n", r );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA( hrec, 1, "epicranius" );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to update row: %d\n", r );
|
|
|
|
|
|
|
|
/* try another valid operation for joins */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
|
|
|
|
todo_wine ok( r == ERROR_SUCCESS, "failed to refresh row: %d\n", r );
|
|
|
|
|
|
|
|
/* try an invalid operation for joins */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
|
|
|
|
ok( r == ERROR_FUNCTION_FAILED, "unexpected result: %d\n", r );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA( hrec, 2, "epicranius" );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to set string: %d\n", r );
|
|
|
|
|
|
|
|
/* primary key cannot be updated */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok( r == ERROR_FUNCTION_FAILED, "failed to update row: %d\n", r );
|
2010-02-06 21:29:15 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2010-02-06 21:29:15 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA( hrec, 1, buf, &size );
|
2010-02-06 21:29:15 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to get record string: %d\n", r );
|
2014-04-23 14:49:34 +00:00
|
|
|
ok( !lstrcmpA( buf, "epicranius" ), "expected 'epicranius', got %s\n", buf );
|
2010-02-06 21:29:15 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_temporary_table(void)
|
|
|
|
{
|
|
|
|
MSICONDITION cond;
|
|
|
|
MSIHANDLE hdb = 0, view = 0, rec;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
char buf[0x10];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(0, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok( hdb, "failed to create db\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, NULL);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_ERROR, "wrong return condition\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "_Tables");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "_Columns");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "_Storages");
|
2008-07-09 11:34:20 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "_Streams");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `P` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "P");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `P2` ( `B` SHORT NOT NULL, `C` CHAR(255) PRIMARY KEY `C`) HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "P2");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "T");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T2` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2009-05-17 07:05:22 +00:00
|
|
|
query = "SELECT * FROM `T2`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "T2");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T3` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) PRIMARY KEY `C`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "T3");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_TRUE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T4` ( `B` SHORT NOT NULL, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "T4");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_NONE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T5` ( `B` SHORT NOT NULL TEMP, `C` CHAR(255) TEMP PRIMARY KEY `C`) HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to add table\n");
|
|
|
|
|
|
|
|
query = "select * from `T`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to query table\n");
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to get column info\n");
|
|
|
|
|
|
|
|
sz = sizeof buf;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to get string\n");
|
2009-05-17 07:05:22 +00:00
|
|
|
ok( 0 == strcmp("G255", buf), "wrong column type\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
sz = sizeof buf;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "failed to get string\n");
|
2009-05-17 07:05:22 +00:00
|
|
|
ok( 0 == strcmp("j2", buf), "wrong column type\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle( rec );
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose( view );
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
|
|
|
/* query the table data */
|
|
|
|
rec = 0;
|
|
|
|
r = do_query(hdb, "select * from `_Tables` where `Name` = 'T'", &rec);
|
|
|
|
ok( r == ERROR_SUCCESS, "temporary table exists in _Tables\n");
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
/* query the column data */
|
|
|
|
rec = 0;
|
|
|
|
r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'B'", &rec);
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
|
|
|
|
if (rec) MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = do_query(hdb, "select * from `_Columns` where `Table` = 'T' AND `Name` = 'C'", &rec);
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "temporary table exists in _Columns\n");
|
|
|
|
if (rec) MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
MsiCloseHandle( hdb );
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_alter(void)
|
|
|
|
{
|
|
|
|
MSICONDITION cond;
|
|
|
|
MSIHANDLE hdb = 0;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok( hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T` ( `B` SHORT NOT NULL TEMPORARY, `C` CHAR(255) TEMPORARY PRIMARY KEY `C`) HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to add table\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
cond = MsiDatabaseIsTablePersistentA(hdb, "T");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok( cond == MSICONDITION_FALSE, "wrong return condition\n");
|
|
|
|
|
|
|
|
query = "ALTER TABLE `T` HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to hold table %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER TABLE `T` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to free table\n");
|
|
|
|
|
|
|
|
query = "ALTER TABLE `T` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to free table\n");
|
|
|
|
|
|
|
|
query = "ALTER TABLE `T` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to free table\n");
|
|
|
|
|
|
|
|
query = "ALTER TABLE `T` HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "failed to hold table %d\n", r);
|
|
|
|
|
|
|
|
/* table T is removed */
|
|
|
|
query = "SELECT * FROM `T`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* create the table again */
|
|
|
|
query = "CREATE TABLE `U` ( `A` INTEGER, `B` INTEGER PRIMARY KEY `B`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* up the ref count */
|
|
|
|
query = "ALTER TABLE `U` HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to free table\n");
|
|
|
|
|
|
|
|
/* add column, no data type */
|
|
|
|
query = "ALTER TABLE `U` ADD `C`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER TABLE `U` ADD `C` INTEGER";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* add column C again */
|
|
|
|
query = "ALTER TABLE `U` ADD `C` INTEGER";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 1, 2, 3, 4 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 5, 6, 7, 8 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `U` WHERE `D` = 8";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER TABLE `U` ADD `D` INTEGER TEMPORARY FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "ALTER COLUMN `D` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* drop the ref count */
|
|
|
|
query = "ALTER TABLE `U` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* table is not empty */
|
|
|
|
query = "SELECT * FROM `U`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* column D is removed */
|
|
|
|
query = "SELECT * FROM `U` WHERE `D` = 8";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `D` ) VALUES ( 9, 10, 11, 12 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* add the column again */
|
|
|
|
query = "ALTER TABLE `U` ADD `E` INTEGER TEMPORARY HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* up the ref count */
|
|
|
|
query = "ALTER TABLE `U` HOLD";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 13, 14, 15, 16 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `U` WHERE `E` = 16";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* drop the ref count */
|
|
|
|
query = "ALTER TABLE `U` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 17, 18, 19, 20 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `U` WHERE `E` = 20";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* drop the ref count */
|
|
|
|
query = "ALTER TABLE `U` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* table still exists */
|
|
|
|
query = "SELECT * FROM `U`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* col E is removed */
|
|
|
|
query = "SELECT * FROM `U` WHERE `E` = 20";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `U` ( `A`, `B`, `C`, `E` ) VALUES ( 20, 21, 22, 23 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* drop the ref count once more */
|
|
|
|
query = "ALTER TABLE `U` FREE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* table still exists */
|
|
|
|
query = "SELECT * FROM `U`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle( hdb );
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_integers(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, view = 0, rec = 0;
|
|
|
|
DWORD count, i;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
/* create a table */
|
|
|
|
query = "CREATE TABLE `integers` ( "
|
|
|
|
"`one` SHORT, `two` INT, `three` INTEGER, `four` LONG, "
|
|
|
|
"`five` SHORT NOT NULL, `six` INT NOT NULL, "
|
|
|
|
"`seven` INTEGER NOT NULL, `eight` LONG NOT NULL "
|
|
|
|
"PRIMARY KEY `one`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute(view, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
r = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
query = "SELECT * FROM `integers`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 8, "Expected 8, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "one"), "Expected one\n");
|
|
|
|
ok(check_record(rec, 2, "two"), "Expected two\n");
|
|
|
|
ok(check_record(rec, 3, "three"), "Expected three\n");
|
|
|
|
ok(check_record(rec, 4, "four"), "Expected four\n");
|
|
|
|
ok(check_record(rec, 5, "five"), "Expected five\n");
|
|
|
|
ok(check_record(rec, 6, "six"), "Expected six\n");
|
|
|
|
ok(check_record(rec, 7, "seven"), "Expected seven\n");
|
|
|
|
ok(check_record(rec, 8, "eight"), "Expected eight\n");
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
count = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(count == 8, "Expected 8, got %d\n", count);
|
|
|
|
ok(check_record(rec, 1, "I2"), "Expected I2\n");
|
|
|
|
ok(check_record(rec, 2, "I2"), "Expected I2\n");
|
|
|
|
ok(check_record(rec, 3, "I2"), "Expected I2\n");
|
|
|
|
ok(check_record(rec, 4, "I4"), "Expected I4\n");
|
|
|
|
ok(check_record(rec, 5, "i2"), "Expected i2\n");
|
|
|
|
ok(check_record(rec, 6, "i2"), "Expected i2\n");
|
|
|
|
ok(check_record(rec, 7, "i2"), "Expected i2\n");
|
|
|
|
ok(check_record(rec, 8, "i4"), "Expected i4\n");
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
/* insert values into it, NULL where NOT NULL is specified */
|
|
|
|
query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
|
|
|
|
"VALUES('', '', '', '', '', '', '', '')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(view, 0);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `integers`";
|
|
|
|
r = do_query(hdb, query, &rec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(r == -1, "record count wrong: %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
/* insert legitimate values into it */
|
|
|
|
query = "INSERT INTO `integers` ( `one`, `two`, `three`, `four`, `five`, `six`, `seven`, `eight` )"
|
|
|
|
"VALUES('', '2', '', '4', '5', '6', '7', '8')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `integers`";
|
|
|
|
r = do_query(hdb, query, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetFieldCount(rec);
|
|
|
|
ok(r == 8, "record count wrong: %d\n", r);
|
|
|
|
|
|
|
|
i = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 3);
|
|
|
|
ok(i == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(i == 2, "Expected 2, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 4);
|
|
|
|
ok(i == 4, "Expected 4, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 5);
|
|
|
|
ok(i == 5, "Expected 5, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 6);
|
|
|
|
ok(i == 6, "Expected 6, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 7);
|
|
|
|
ok(i == 7, "Expected 7, got %d\n", i);
|
|
|
|
i = MsiRecordGetInteger(rec, 8);
|
|
|
|
ok(i == 8, "Expected 8, got %d\n", i);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == TRUE, "file didn't exist after commit\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_update(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, view = 0, rec = 0;
|
|
|
|
CHAR result[MAX_PATH];
|
|
|
|
const char *query;
|
|
|
|
DWORD size;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
/* create the Control table */
|
|
|
|
query = "CREATE TABLE `Control` ( "
|
|
|
|
"`Dialog_` CHAR(72) NOT NULL, `Control` CHAR(50) NOT NULL, `Type` SHORT NOT NULL, "
|
|
|
|
"`X` SHORT NOT NULL, `Y` SHORT NOT NULL, `Width` SHORT NOT NULL, `Height` SHORT NOT NULL,"
|
|
|
|
"`Attributes` LONG, `Property` CHAR(50), `Text` CHAR(0) LOCALIZABLE, "
|
|
|
|
"`Control_Next` CHAR(50), `Help` CHAR(50) LOCALIZABLE PRIMARY KEY `Dialog_`, `Control`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute(view, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
r = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* add a control */
|
|
|
|
query = "INSERT INTO `Control` ( "
|
|
|
|
"`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
|
|
|
|
"`Property`, `Text`, `Control_Next`, `Help` )"
|
|
|
|
"VALUES('ErrorDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* add a second control */
|
|
|
|
query = "INSERT INTO `Control` ( "
|
|
|
|
"`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
|
|
|
|
"`Property`, `Text`, `Control_Next`, `Help` )"
|
|
|
|
"VALUES('ErrorDialog', 'Button', '1', '5', '5', '5', '5', '', '', '', '')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* add a third control */
|
|
|
|
query = "INSERT INTO `Control` ( "
|
|
|
|
"`Dialog_`, `Control`, `Type`, `X`, `Y`, `Width`, `Height`, "
|
|
|
|
"`Property`, `Text`, `Control_Next`, `Help` )"
|
|
|
|
"VALUES('AnotherDialog', 'ErrorText', '1', '5', '5', '5', '5', '', '', '', '')";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* bad table */
|
|
|
|
query = "UPDATE `NotATable` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* bad set column */
|
|
|
|
query = "UPDATE `Control` SET `NotAColumn` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* bad where condition */
|
|
|
|
query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `NotAColumn` = 'ErrorDialog'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
/* just the dialog_ specified */
|
|
|
|
query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* check the modified text */
|
|
|
|
query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2015-03-09 20:28:54 +00:00
|
|
|
ok(!result[0], "Expected an empty string, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* dialog_ and control specified */
|
|
|
|
query = "UPDATE `Control` SET `Text` = 'this is text' WHERE `Dialog_` = 'ErrorDialog' AND `Control` = 'ErrorText'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* check the modified text */
|
|
|
|
query = "SELECT `Text` FROM `Control` WHERE `Control` = 'ErrorText'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2015-03-09 20:28:54 +00:00
|
|
|
ok(!result[0], "Expected an empty string, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* no where condition */
|
|
|
|
query = "UPDATE `Control` SET `Text` = 'this is text'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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 = MsiViewClose(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* check the modified text */
|
|
|
|
query = "SELECT `Text` FROM `Control`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, result, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(result, "this is text"), "Expected `this is text`, got %s\n", result);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
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, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(view);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Apple` ( `Banana` CHAR(72) NOT NULL, "
|
|
|
|
"`Orange` CHAR(72), `Pear` INT PRIMARY KEY `Banana`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
|
|
|
|
"VALUES('one', 'two', 3)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
|
|
|
|
"VALUES('three', 'four', 5)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Apple` ( `Banana`, `Orange`, `Pear` )"
|
|
|
|
"VALUES('six', 'two', 7)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
rec = MsiCreateRecord(2);
|
|
|
|
MsiRecordSetInteger(rec, 1, 8);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 2, "two");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "UPDATE `Apple` SET `Pear` = ? WHERE `Orange` = ?";
|
|
|
|
r = run_query(hdb, rec, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
query = "SELECT `Pear` FROM `Apple` ORDER BY `Orange`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == 8, "Expected 8, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == 8, "Expected 8, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expectd ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseCommit failed\n");
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_special_tables(void)
|
|
|
|
{
|
|
|
|
const char *query;
|
|
|
|
MSIHANDLE hdb = 0;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `_Properties` ( "
|
|
|
|
"`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
2008-07-09 11:34:20 +00:00
|
|
|
query = "CREATE TABLE `_Storages` ( "
|
|
|
|
"`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "CREATE TABLE `_Streams` ( "
|
|
|
|
"`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Streams table\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "CREATE TABLE `_Tables` ( "
|
|
|
|
"`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Tables table\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `_Columns` ( "
|
|
|
|
"`foo` INT NOT NULL, `bar` INT LOCALIZABLE PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "created _Columns table\n");
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
}
|
|
|
|
|
2009-08-08 12:48:20 +00:00
|
|
|
static void test_tables_order(void)
|
|
|
|
{
|
|
|
|
const char *query;
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
UINT r;
|
|
|
|
char buffer[100];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `foo` ( "
|
|
|
|
"`baz` INT NOT NULL PRIMARY KEY `baz`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `bar` ( "
|
|
|
|
"`foo` INT NOT NULL PRIMARY KEY `foo`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `baz` ( "
|
|
|
|
"`bar` INT NOT NULL, "
|
|
|
|
"`baz` INT NOT NULL, "
|
|
|
|
"`foo` INT NOT NULL PRIMARY KEY `bar`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
/* The names of the tables in the _Tables table must
|
|
|
|
be in the same order as these names are created in
|
|
|
|
the strings table. */
|
|
|
|
query = "SELECT * FROM `_Tables`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
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");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
/* The names of the tables in the _Columns table must
|
|
|
|
be in the same order as these names are created in
|
|
|
|
the strings table. */
|
|
|
|
query = "SELECT * FROM `_Columns`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
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");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "baz"), "Expected baz, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "bar"), "Expected bar, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "foo"), "Expected foo, got %s\n", buffer);
|
2009-08-08 12:48:20 +00:00
|
|
|
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, "MsiCloseHandle failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2009-08-08 12:48:20 +00:00
|
|
|
}
|
|
|
|
|
2009-10-25 11:06:38 +00:00
|
|
|
static void test_rows_order(void)
|
|
|
|
{
|
|
|
|
const char *query;
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
UINT r;
|
|
|
|
char buffer[100];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `foo` ( "
|
|
|
|
"`bar` LONGCHAR NOT NULL PRIMARY KEY `bar`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'A' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'B' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'C' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'D' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'E' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `foo` "
|
|
|
|
"( `bar` ) VALUES ( 'F' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `bar` ( "
|
|
|
|
"`foo` LONGCHAR NOT NULL, "
|
|
|
|
"`baz` LONGCHAR NOT NULL "
|
|
|
|
"PRIMARY KEY `foo` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( 'C', 'E' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( 'F', 'A' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( 'A', 'B' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( 'D', 'E' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table\n");
|
|
|
|
|
|
|
|
/* The rows of the table must be ordered by the column values of
|
|
|
|
each row. For strings, the column value is the string id
|
|
|
|
in the string table. */
|
|
|
|
|
|
|
|
query = "SELECT * FROM `bar`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-10-25 11:06:38 +00:00
|
|
|
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");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "B"), "Expected B, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "C"), "Expected E, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "D"), "Expected D, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "E"), "Expected E, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "F"), "Expected F, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2009-10-25 11:06:38 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "A"), "Expected A, got %s\n", buffer);
|
2009-10-25 11:06:38 +00:00
|
|
|
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, "MsiCloseHandle failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2009-10-25 11:06:38 +00:00
|
|
|
}
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
static void test_collation(void)
|
|
|
|
{
|
|
|
|
static const WCHAR query1[] =
|
|
|
|
{'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
|
|
|
|
'(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
|
|
|
|
'(','\'','a',0x30a,'\'',',','\'','C','\'',')',0};
|
|
|
|
static const WCHAR query2[] =
|
|
|
|
{'I','N','S','E','R','T',' ','I','N','T','O',' ','`','b','a','r','`',' ',
|
|
|
|
'(','`','f','o','o','`',',','`','b','a','z','`',')',' ','V','A','L','U','E','S',' ',
|
|
|
|
'(','\'',0xe5,'\'',',','\'','D','\'',')',0};
|
|
|
|
static const WCHAR query3[] =
|
|
|
|
{'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','b','a','z','`',' ',
|
|
|
|
'(',' ','`','a',0x30a,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',',',
|
|
|
|
' ','`',0xe5,'`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ','N','U','L','L',' ',
|
|
|
|
'P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','a',0x30a,'`',')',0};
|
|
|
|
static const WCHAR query4[] =
|
|
|
|
{'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`','a',0x30a,'`',' ',
|
|
|
|
'(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
|
|
|
|
'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
|
|
|
|
static const WCHAR query5[] =
|
|
|
|
{'C','R','E','A','T','E',' ','T','A','B','L','E',' ','`',0xe5,'`',' ',
|
|
|
|
'(',' ','`','f','o','o','`',' ','L','O','N','G','C','H','A','R',' ','N','O','T',' ',
|
|
|
|
'N','U','L','L',' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ','`','f','o','o','`',')',0};
|
|
|
|
static const WCHAR query6[] =
|
|
|
|
{'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','b','a','r','`',' ','W','H','E','R','E',
|
|
|
|
' ','`','f','o','o','`',' ','=','\'',0xe5,'\'',0};
|
|
|
|
static const WCHAR letter_C[] = {'C',0};
|
|
|
|
static const WCHAR letter_D[] = {'D',0};
|
|
|
|
static const WCHAR letter_a_ring[] = {'a',0x30a,0};
|
|
|
|
static const WCHAR letter_a_with_ring[] = {0xe5,0};
|
|
|
|
const char *query;
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
UINT r;
|
|
|
|
char buffer[100];
|
|
|
|
WCHAR bufferW[100];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `bar` ( "
|
|
|
|
"`foo` LONGCHAR NOT NULL, "
|
|
|
|
"`baz` LONGCHAR NOT NULL "
|
|
|
|
"PRIMARY KEY `foo` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to create table\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "wrong error %u\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( '\2', 'A' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `bar` "
|
|
|
|
"( `foo`, `baz` ) VALUES ( '\1', 'B' )");
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
|
|
|
|
|
|
|
|
r = run_queryW(hdb, 0, query1);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
|
|
|
|
|
|
|
|
r = run_queryW(hdb, 0, query2);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot add value to table %u\n", r);
|
|
|
|
|
|
|
|
r = run_queryW(hdb, 0, query3);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
|
|
|
|
|
|
|
|
r = run_queryW(hdb, 0, query4);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
|
|
|
|
|
|
|
|
r = run_queryW(hdb, 0, query5);
|
|
|
|
ok(r == ERROR_SUCCESS, "cannot create table %u\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `bar`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2012-01-21 17:21:57 +00:00
|
|
|
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");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "\2"), "Expected \\2, got '%s'\n", buffer);
|
2012-01-21 17:21:57 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "A"), "Expected A, got '%s'\n", buffer);
|
2012-01-21 17:21:57 +00:00
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "\1"), "Expected \\1, got '%s'\n", buffer);
|
2012-01-21 17:21:57 +00:00
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "B"), "Expected B, got '%s'\n", buffer);
|
2012-01-21 17:21:57 +00:00
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!memcmp(bufferW, letter_a_ring, sizeof(letter_a_ring)),
|
|
|
|
"Expected %s, got %s\n", wine_dbgstr_w(letter_a_ring), wine_dbgstr_w(bufferW));
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpW(bufferW, letter_C), "Expected C, got %s\n", wine_dbgstr_w(bufferW));
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
|
|
|
|
"Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
r = MsiDatabaseOpenViewW(hdb, query6, &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");
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 1, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!memcmp(bufferW, letter_a_with_ring, sizeof(letter_a_with_ring)),
|
|
|
|
"Expected %s, got %s\n", wine_dbgstr_w(letter_a_with_ring), wine_dbgstr_w(bufferW));
|
|
|
|
sz = sizeof(bufferW) / sizeof(bufferW[0]);
|
|
|
|
r = MsiRecordGetStringW(hrec, 2, bufferW, &sz);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpW(bufferW, letter_D), "Expected D, got %s\n", wine_dbgstr_w(bufferW));
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "MsiViewFetch failed\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, "MsiCloseHandle failed\n");
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2012-01-21 17:21:57 +00:00
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static void test_select_markers(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, rec, view, res;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
CHAR buf[MAX_PATH];
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok( hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
r = run_query(hdb, 0,
|
|
|
|
"CREATE TABLE `Table` (`One` CHAR(72), `Two` CHAR(72), `Three` SHORT PRIMARY KEY `One`, `Two`, `Three`)");
|
|
|
|
ok(r == S_OK, "cannot create table: %d\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `Table` "
|
|
|
|
"( `One`, `Two`, `Three` ) VALUES ( 'apple', 'one', 1 )");
|
|
|
|
ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `Table` "
|
|
|
|
"( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 1 )");
|
|
|
|
ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `Table` "
|
|
|
|
"( `One`, `Two`, `Three` ) VALUES ( 'apple', 'two', 2 )");
|
|
|
|
ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
|
|
|
|
|
|
|
|
r = run_query(hdb, 0, "INSERT INTO `Table` "
|
|
|
|
"( `One`, `Two`, `Three` ) VALUES ( 'banana', 'three', 3 )");
|
|
|
|
ok(r == S_OK, "cannot add file to the Media table: %d\n", r);
|
|
|
|
|
|
|
|
rec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "apple");
|
|
|
|
MsiRecordSetStringA(rec, 2, "two");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `One`=? AND `Two`=? ORDER BY `Three`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 2, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(res, 3);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(res);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 2, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(res, 3);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(res);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
rec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(rec, 1, "one");
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiRecordSetInteger(rec, 2, 1);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `Two`<>? AND `Three`>? ORDER BY `Three`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2008-02-10 13:22:36 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "apple"), "Expected apple, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 2, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(res, 3);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(res);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "banana"), "Expected banana, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(res, 2, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "three"), "Expected three, got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(res, 3);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(res);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &res);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
MsiCloseHandle(hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_viewmodify_update(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
2012-01-21 17:21:57 +00:00
|
|
|
UINT i, test_max, offset, count;
|
2008-02-10 13:22:36 +00:00
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
query = "INSERT INTO `table` (`A`, `B`) VALUES (1, 2)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
query = "INSERT INTO `table` (`A`, `B`) VALUES (3, 4)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
query = "INSERT INTO `table` (`A`, `B`) VALUES (5, 6)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
query = "SELECT `B` FROM `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
|
|
|
|
|
|
|
|
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 `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 0, "Expected 0, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 4, "Expected 4, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 6, "Expected 6, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* loop through all elements */
|
|
|
|
query = "SELECT `B` FROM `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
|
|
|
|
while (TRUE)
|
|
|
|
{
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
if (r != ERROR_SUCCESS)
|
|
|
|
break;
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
|
|
|
|
|
|
|
|
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 `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 0, "Expected 0, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 0, "Expected 0, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewFetch failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 0, "Expected 0, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
query = "CREATE TABLE `table2` (`A` INT, `B` INT PRIMARY KEY `A`)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
query = "INSERT INTO `table2` (`A`, `B`) VALUES (?, ?)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, query, &hview );
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
|
|
|
|
test_max = 100;
|
|
|
|
offset = 1234;
|
|
|
|
for(i = 0; i < test_max; i++)
|
|
|
|
{
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord( 2 );
|
|
|
|
MsiRecordSetInteger( hrec, 1, test_max - i );
|
|
|
|
MsiRecordSetInteger( hrec, 2, i );
|
|
|
|
|
|
|
|
r = MsiViewExecute( hview, hrec );
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle( hrec );
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = MsiViewClose( hview );
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
r = MsiCloseHandle( hview );
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
|
|
|
|
/* Update. */
|
|
|
|
query = "SELECT * FROM `table2` ORDER BY `B`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, query, &hview);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute( hview, 0 );
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
UINT b = MsiRecordGetInteger( hrec, 2 );
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger( hrec, 2, b + offset);
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify( hview, MSIMODIFY_UPDATE, hrec );
|
|
|
|
ok(r == ERROR_SUCCESS, "Got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
ok(count == test_max, "Got count %d\n", count);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* Recheck. */
|
|
|
|
query = "SELECT * FROM `table2` ORDER BY `B`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, query, &hview);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute( hview, 0 );
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
while (MsiViewFetch( hview, &hrec ) == ERROR_SUCCESS)
|
|
|
|
{
|
|
|
|
UINT a = MsiRecordGetInteger( hrec, 1 );
|
|
|
|
UINT b = MsiRecordGetInteger( hrec, 2 );
|
|
|
|
ok( ( test_max - a + offset) == b, "Got (%d, %d), expected (%d, %d)\n",
|
|
|
|
a, b, test_max - a + offset, b);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
ok(count == test_max, "Got count %d\n", count);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
r = MsiCloseHandle( hdb );
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
|
|
|
|
}
|
|
|
|
|
2009-08-08 12:48:20 +00:00
|
|
|
static void test_viewmodify_assign(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
/* setup database */
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2009-08-08 12:48:20 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase failed\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `table` (`A` INT, `B` INT PRIMARY KEY `A`)";
|
|
|
|
r = run_query( hdb, 0, query );
|
|
|
|
ok(r == ERROR_SUCCESS, "query failed\n");
|
|
|
|
|
|
|
|
/* assign to view, new primary key */
|
|
|
|
query = "SELECT * FROM `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(2);
|
|
|
|
ok(hrec != 0, "MsiCreateRecord failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 1);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
r = MsiRecordSetInteger(hrec, 2, 2);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
|
|
|
|
|
|
|
|
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 `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* assign to view, primary key matches */
|
|
|
|
query = "SELECT * FROM `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "MsiDatabaseOpenView failed\n");
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewExecute failed\n");
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(2);
|
|
|
|
ok(hrec != 0, "MsiCreateRecord failed\n");
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 1);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
r = MsiRecordSetInteger(hrec, 2, 4);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to set integer\n");
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_ASSIGN, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewModify failed: %d\n", r);
|
|
|
|
|
|
|
|
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 `table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2009-08-08 12:48:20 +00:00
|
|
|
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");
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 4, "Expected 4, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "failed to close record\n");
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiViewClose failed\n");
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiCloseHandle failed\n");
|
|
|
|
|
|
|
|
/* close database */
|
|
|
|
r = MsiCloseHandle( hdb );
|
|
|
|
ok(r == ERROR_SUCCESS, "MsiOpenDatabase close failed\n");
|
|
|
|
}
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
static const WCHAR data10[] = { /* MOO */
|
|
|
|
0x8001, 0x000b,
|
|
|
|
};
|
|
|
|
static const WCHAR data11[] = { /* AAR */
|
|
|
|
0x8002, 0x8005,
|
|
|
|
0x000c, 0x000f,
|
|
|
|
};
|
|
|
|
static const char data12[] = /* _StringData */
|
|
|
|
"MOOABAARCDonetwofourfive";
|
|
|
|
static const WCHAR data13[] = { /* _StringPool */
|
|
|
|
/* len, refs */
|
|
|
|
0, 0, /* string 0 '' */
|
|
|
|
0, 0, /* string 1 '' */
|
|
|
|
0, 0, /* string 2 '' */
|
|
|
|
0, 0, /* string 3 '' */
|
|
|
|
0, 0, /* string 4 '' */
|
|
|
|
3, 3, /* string 5 'MOO' */
|
|
|
|
1, 1, /* string 6 'A' */
|
|
|
|
1, 1, /* string 7 'B' */
|
|
|
|
3, 3, /* string 8 'AAR' */
|
|
|
|
1, 1, /* string 9 'C' */
|
|
|
|
1, 1, /* string a 'D' */
|
|
|
|
3, 1, /* string b 'one' */
|
|
|
|
3, 1, /* string c 'two' */
|
|
|
|
0, 0, /* string d '' */
|
|
|
|
4, 1, /* string e 'four' */
|
|
|
|
4, 1, /* string f 'five' */
|
|
|
|
};
|
|
|
|
|
|
|
|
static void test_stringtable(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
IStorage *stg = NULL;
|
|
|
|
IStream *stm;
|
|
|
|
WCHAR name[0x20];
|
|
|
|
HRESULT hr;
|
|
|
|
const char *query;
|
|
|
|
char buffer[MAX_PATH];
|
|
|
|
WCHAR data[MAX_PATH];
|
|
|
|
DWORD sz, read;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
static const DWORD mode = STGM_DIRECT | STGM_READ | STGM_SHARE_DENY_WRITE;
|
|
|
|
static const WCHAR stringdata[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0}; /* _StringData */
|
|
|
|
static const WCHAR stringpool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0}; /* _StringPool */
|
|
|
|
static const WCHAR moo[] = {0x4840, 0x3e16, 0x4818, 0}; /* MOO */
|
|
|
|
static const WCHAR aar[] = {0x4840, 0x3a8a, 0x481b, 0}; /* AAR */
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `MOO` (`A` INT, `B` CHAR(72) PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `AAR` (`C` INT, `D` CHAR(72) PRIMARY KEY `C`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* insert persistent row */
|
|
|
|
query = "INSERT INTO `MOO` (`A`, `B`) VALUES (1, 'one')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* insert persistent row */
|
|
|
|
query = "INSERT INTO `AAR` (`C`, `D`) VALUES (2, 'two')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* open a view */
|
|
|
|
query = "SELECT * FROM `MOO`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(2);
|
|
|
|
|
|
|
|
r = MsiRecordSetInteger(hrec, 1, 3);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStringA(hrec, 2, "three");
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* insert a nonpersistent row */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* insert persistent row */
|
|
|
|
query = "INSERT INTO `MOO` (`A`, `B`) VALUES (4, 'four')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* insert persistent row */
|
|
|
|
query = "INSERT INTO `AAR` (`C`, `D`) VALUES (5, 'five')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `MOO`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetFieldCount(hrec);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "one"), "Expected one, got '%s'\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `AAR`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetFieldCount(hrec);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "two"), "Expected two, got '%s'\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetFieldCount(hrec);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "five"), "Expected five, got '%s'\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, 0x20);
|
|
|
|
hr = StgOpenStorage(name, NULL, mode, NULL, 0, &stg);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(stg != NULL, "Expected non-NULL storage\n");
|
|
|
|
|
|
|
|
hr = IStorage_OpenStream(stg, moo, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
|
|
|
hr = IStream_Read(stm, data, MAX_PATH, &read);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(read == 4, "Expected 4, got %d\n", read);
|
|
|
|
todo_wine ok(!memcmp(data, data10, read), "Unexpected data\n");
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
hr = IStream_Release(stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
|
|
|
|
hr = IStorage_OpenStream(stg, aar, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
|
|
|
hr = IStream_Read(stm, data, MAX_PATH, &read);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(read == 8, "Expected 8, got %d\n", read);
|
|
|
|
todo_wine
|
|
|
|
{
|
|
|
|
ok(!memcmp(data, data11, read), "Unexpected data\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
hr = IStream_Release(stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
|
|
|
|
hr = IStorage_OpenStream(stg, stringdata, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
|
|
|
hr = IStream_Read(stm, buffer, MAX_PATH, &read);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(read == 24, "Expected 24, got %d\n", read);
|
|
|
|
ok(!memcmp(buffer, data12, read), "Unexpected data\n");
|
|
|
|
|
|
|
|
hr = IStream_Release(stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
|
|
|
|
hr = IStorage_OpenStream(stg, stringpool, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
|
|
|
hr = IStream_Read(stm, data, MAX_PATH, &read);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
todo_wine
|
|
|
|
{
|
|
|
|
ok(read == 64, "Expected 64, got %d\n", read);
|
|
|
|
ok(!memcmp(data, data13, read), "Unexpected data\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
hr = IStream_Release(stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
|
|
|
|
hr = IStorage_Release(stg);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_viewmodify_delete(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, hview = 0, hrec = 0;
|
|
|
|
UINT r;
|
|
|
|
const char *query;
|
|
|
|
char buffer[0x100];
|
|
|
|
DWORD sz;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
/* just MsiOpenDatabase should not create a file */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
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, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
|
|
|
|
"VALUES('1', 'Alan', '5030581')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
|
|
|
|
"VALUES('2', 'Barry', '928440')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `phone` ( `id`, `name`, `number` )"
|
|
|
|
"VALUES('3', 'Cindy', '2937550')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `phone` WHERE `id` <= 2";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* delete 1 */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* delete 2 */
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `phone`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "Cindy"), "Expected Cindy, got %s\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 3, buffer, &sz);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "2937550"), "Expected 2937550, got %s\n", buffer);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
r = MsiCloseHandle(hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewClose(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiCloseHandle(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const WCHAR _Tables[] = {0x4840, 0x3f7f, 0x4164, 0x422f, 0x4836, 0};
|
|
|
|
static const WCHAR _StringData[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3b6a, 0x45e4, 0x4824, 0};
|
|
|
|
static const WCHAR _StringPool[] = {0x4840, 0x3f3f, 0x4577, 0x446c, 0x3e6a, 0x44b2, 0x482f, 0};
|
|
|
|
|
|
|
|
static const WCHAR data14[] = { /* _StringPool */
|
|
|
|
/* len, refs */
|
|
|
|
0, 0, /* string 0 '' */
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct {
|
|
|
|
LPCWSTR name;
|
|
|
|
const void *data;
|
|
|
|
DWORD size;
|
|
|
|
} database_table_data[] =
|
|
|
|
{
|
|
|
|
{_Tables, NULL, 0},
|
|
|
|
{_StringData, NULL, 0},
|
|
|
|
{_StringPool, data14, sizeof data14},
|
|
|
|
};
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
static void enum_stream_names(IStorage *stg)
|
2008-02-10 13:22:36 +00:00
|
|
|
{
|
|
|
|
IEnumSTATSTG *stgenum = NULL;
|
|
|
|
IStream *stm;
|
|
|
|
HRESULT hr;
|
|
|
|
STATSTG stat;
|
|
|
|
ULONG n, count;
|
|
|
|
BYTE data[MAX_PATH];
|
|
|
|
BYTE check[MAX_PATH];
|
|
|
|
DWORD sz;
|
|
|
|
|
|
|
|
memset(check, 'a', MAX_PATH);
|
|
|
|
|
|
|
|
hr = IStorage_EnumElements(stg, 0, NULL, 0, &stgenum);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
|
|
|
|
n = 0;
|
|
|
|
while(TRUE)
|
|
|
|
{
|
|
|
|
count = 0;
|
|
|
|
hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &count);
|
|
|
|
if(FAILED(hr) || !count)
|
|
|
|
break;
|
|
|
|
|
|
|
|
ok(!lstrcmpW(stat.pwcsName, database_table_data[n].name),
|
|
|
|
"Expected table %d name to match\n", n);
|
|
|
|
|
|
|
|
stm = NULL;
|
|
|
|
hr = IStorage_OpenStream(stg, stat.pwcsName, NULL,
|
|
|
|
STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
2009-12-22 09:14:17 +00:00
|
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
sz = MAX_PATH;
|
|
|
|
memset(data, 'a', MAX_PATH);
|
|
|
|
hr = IStream_Read(stm, data, sz, &count);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
|
|
|
|
ok(count == database_table_data[n].size,
|
|
|
|
"Expected %d, got %d\n", database_table_data[n].size, count);
|
|
|
|
|
|
|
|
if (!database_table_data[n].size)
|
|
|
|
ok(!memcmp(data, check, MAX_PATH), "data should not be changed\n");
|
|
|
|
else
|
|
|
|
ok(!memcmp(data, database_table_data[n].data, database_table_data[n].size),
|
|
|
|
"Expected table %d data to match\n", n);
|
|
|
|
|
|
|
|
IStream_Release(stm);
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
|
|
|
|
ok(n == 3, "Expected 3, got %d\n", n);
|
|
|
|
|
|
|
|
IEnumSTATSTG_Release(stgenum);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_defaultdatabase(void)
|
|
|
|
{
|
|
|
|
UINT r;
|
|
|
|
HRESULT hr;
|
|
|
|
MSIHANDLE hdb;
|
|
|
|
IStorage *stg = NULL;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
|
|
|
hr = StgOpenStorage(msifileW, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
ok(stg != NULL, "Expected non-NULL stg\n");
|
|
|
|
|
|
|
|
enum_stream_names(stg);
|
|
|
|
|
|
|
|
IStorage_Release(stg);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_order(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
2008-05-09 17:35:45 +00:00
|
|
|
CHAR buffer[MAX_PATH];
|
2008-02-10 13:22:36 +00:00
|
|
|
LPCSTR query;
|
2008-05-09 17:35:45 +00:00
|
|
|
UINT r, sz;
|
2008-02-10 13:22:36 +00:00
|
|
|
int val;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
2008-04-04 16:43:16 +00:00
|
|
|
query = "CREATE TABLE `Empty` ( `A` SHORT NOT NULL PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
query = "CREATE TABLE `Mesa` ( `A` SHORT NOT NULL, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 1, 2, 9 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 3, 4, 7 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Mesa` ( `A`, `B`, `C` ) VALUES ( 5, 6, 8 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Sideboard` ( `D` SHORT NOT NULL, `E` SHORT, `F` SHORT PRIMARY KEY `D`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 10, 11, 18 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 12, 13, 16 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Sideboard` ( `D`, `E`, `F` ) VALUES ( 14, 15, 17 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT `A`, `B` FROM `Mesa` ORDER BY `C`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 3, "Expected 3, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 4, "Expected 3, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 5, "Expected 5, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 6, "Expected 6, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 1, "Expected 1, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 2, "Expected 2, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT `A`, `D` FROM `Mesa`, `Sideboard` ORDER BY `F`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 1, "Expected 1, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 12, "Expected 12, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 3, "Expected 3, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 12, "Expected 12, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 5, "Expected 5, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 12, "Expected 12, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 1, "Expected 1, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 14, "Expected 14, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 3, "Expected 3, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 14, "Expected 14, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 5, "Expected 5, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 14, "Expected 14, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 1, "Expected 1, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 10, "Expected 10, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 3, "Expected 3, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 10, "Expected 10, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(val == 5, "Expected 5, got %d\n", val);
|
|
|
|
|
|
|
|
val = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(val == 10, "Expected 10, got %d\n", val);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
2008-04-04 16:43:16 +00:00
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Empty` ORDER BY `A`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
2008-05-09 17:35:45 +00:00
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Buffet` ( `One` CHAR(72), `Two` SHORT PRIMARY KEY `One`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'uno', 2)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'dos', 3)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Buffet` ( `One`, `Two` ) VALUES ( 'tres', 1)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Buffet` WHERE `One` = 'dos' ORDER BY `Two`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &sz);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buffer, "dos"), "Expected \"dos\", got \"%s\"\n", buffer);
|
2008-05-09 17:35:45 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_viewmodify_delete_temporary(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` SHORT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(1);
|
|
|
|
MsiRecordSetInteger(hrec, 1, 1);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(1);
|
|
|
|
MsiRecordSetInteger(hrec, 1, 2);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(1);
|
|
|
|
MsiRecordSetInteger(hrec, 1, 3);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(1);
|
|
|
|
MsiRecordSetInteger(hrec, 1, 4);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `A` = 2";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `A` = 3";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_DELETE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` ORDER BY `A`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 4, "Expected 4, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
2009-01-31 14:17:07 +00:00
|
|
|
static void test_deleterow(void)
|
2008-02-10 13:22:36 +00:00
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` (`A`) VALUES ('one')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` (`A`) VALUES ('two')";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DELETE FROM `Table` WHERE `A` = 'one'";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_READONLY, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "two"), "Expected two, got %s\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const CHAR import_dat[] = "A\n"
|
|
|
|
"s72\n"
|
|
|
|
"Table\tA\n"
|
|
|
|
"This is a new 'string' ok\n";
|
|
|
|
|
|
|
|
static void test_quotes(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a 'string' ok' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( \"This is a 'string' ok\" )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( \"test\" )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a ''string'' ok' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a '''string''' ok' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \'string\' ok' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( 'This is a \"string\" ok' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "This is a \"string\" ok"),
|
2009-05-17 07:05:22 +00:00
|
|
|
"Expected \"This is a \"string\" ok\", got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
write_file("import.idt", import_dat, (sizeof(import_dat) - 1) * sizeof(char));
|
|
|
|
|
|
|
|
r = MsiDatabaseImportA(hdb, CURR_DIR, "import.idt");
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
DeleteFileA("import.idt");
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "This is a new 'string' ok"),
|
2008-04-04 16:43:16 +00:00
|
|
|
"Expected \"This is a new 'string' ok\", got %s\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_carriagereturn(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table`\r ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` \r( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE\r TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE\r `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` (\r `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A`\r CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72)\r NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT\r NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT \rNULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL\r PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL \rPRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY\r KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY \rKEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY\r `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A`\r )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )\r";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `\rOne` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Tw\ro` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Three\r` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A\r` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `\rA` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A` CHAR(72\r) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A` CHAR(\r72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `\rA` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Four` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A\r` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-02-10 13:22:36 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(!lstrcmpA(buf, "\rOne"), "Expected \"\\rOne\", got \"%s\"\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(!lstrcmpA(buf, "Tw\ro"), "Expected \"Tw\\ro\", got \"%s\"\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(!lstrcmpA(buf, "Three\r"), "Expected \"Three\r\", got \"%s\"\n", buf);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
2008-02-10 13:22:36 +00:00
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
2008-04-04 16:43:16 +00:00
|
|
|
static void test_noquotes(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-04-04 16:43:16 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE Table ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( A CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table2` ( `A` CHAR(72) NOT NULL PRIMARY KEY A )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table3` ( A CHAR(72) NOT NULL PRIMARY KEY A )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table2"), "Expected \"Table2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "Table3"), "Expected \"Table3\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "INSERT INTO Table ( `A` ) VALUES ( 'hi' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( A ) VALUES ( 'hi' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A` ) VALUES ( hi )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM Table WHERE `A` = 'hi'";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `A` = hi";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM Table";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM Table2";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE A = 'hi'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void read_file_data(LPCSTR filename, LPSTR buffer)
|
|
|
|
{
|
2009-01-18 09:03:44 +00:00
|
|
|
HANDLE file;
|
2008-04-04 16:43:16 +00:00
|
|
|
DWORD read;
|
|
|
|
|
2009-01-18 09:03:44 +00:00
|
|
|
file = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL );
|
2008-04-04 16:43:16 +00:00
|
|
|
ZeroMemory(buffer, MAX_PATH);
|
2009-01-18 09:03:44 +00:00
|
|
|
ReadFile(file, buffer, MAX_PATH, &read, NULL);
|
|
|
|
CloseHandle(file);
|
2008-04-04 16:43:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_forcecodepage(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb;
|
|
|
|
const char *query;
|
|
|
|
char buffer[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2012-01-21 17:21:57 +00:00
|
|
|
GetCurrentDirectoryA(MAX_PATH, CURR_DIR);
|
2008-04-04 16:43:16 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_ForceCodepage`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_ForceCodepage`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_ForceCodepage`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_DIRECT, &hdb);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_ForceCodepage`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX, "Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
read_file_data("forcecodepage.idt", buffer);
|
|
|
|
ok(!lstrcmpA(buffer, "\r\n\r\n0\t_ForceCodepage\r\n"),
|
2012-01-21 17:21:57 +00:00
|
|
|
"Expected \"\r\n\r\n0\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
|
|
|
|
|
|
|
|
create_file_data("forcecodepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
|
|
|
|
|
|
|
|
r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseExportA(hdb, "_ForceCodepage", CURR_DIR, "forcecodepage.idt");
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
read_file_data("forcecodepage.idt", buffer);
|
|
|
|
ok(!lstrcmpA(buffer, "\r\n\r\n850\t_ForceCodepage\r\n"),
|
|
|
|
"Expected \"\r\n\r\n850\t_ForceCodepage\r\n\", got \"%s\"\n", buffer);
|
|
|
|
|
|
|
|
create_file_data("forcecodepage.idt", "\r\n\r\n9999\t_ForceCodepage\r\n", 0);
|
|
|
|
|
|
|
|
r = MsiDatabaseImportA(hdb, CURR_DIR, "forcecodepage.idt");
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-04-04 16:43:16 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
DeleteFileA("forcecodepage.idt");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_viewmodify_refresh(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
char buffer[MAX_PATH];
|
|
|
|
UINT r;
|
|
|
|
DWORD size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-04-04 16:43:16 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` CHAR(72) NOT NULL, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hi', 1 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hi'";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buffer, "hi"), "Expected \"hi\", got \"%s\"\n", buffer);
|
|
|
|
ok(size == 2, "Expected 2, got %d\n", size);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hello', 3 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `B` = 3";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-04-04 16:43:16 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "UPDATE `Table` SET `B` = 2 WHERE `A` = 'hello'";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 'hithere', 3 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buffer, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buffer, "hello"), "Expected \"hello\", got \"%s\"\n", buffer);
|
|
|
|
ok(size == 5, "Expected 5, got %d\n", size);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
2008-05-09 17:35:45 +00:00
|
|
|
static void test_where_viewmodify(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
const char *query;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2008-05-09 17:35:45 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Table` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 1, 2 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 3, 4 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Table` ( `A`, `B` ) VALUES ( 5, 6 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* `B` = 3 doesn't match, but the view shouldn't be executed */
|
|
|
|
query = "SELECT * FROM `Table` WHERE `B` = 3";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
hrec = MsiCreateRecord(2);
|
|
|
|
MsiRecordSetInteger(hrec, 1, 7);
|
|
|
|
MsiRecordSetInteger(hrec, 2, 8);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_INSERT_TEMPORARY, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `A` = 7";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 7, "Expected 7, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 8, "Expected 8, got %d\n", r);
|
|
|
|
|
|
|
|
MsiRecordSetInteger(hrec, 2, 9);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_UPDATE, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Table` WHERE `A` = 7";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-05-09 17:35:45 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 7, "Expected 7, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 9, "Expected 9, got %d\n", r);
|
|
|
|
|
|
|
|
query = "UPDATE `Table` SET `B` = 10 WHERE `A` = 7";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewModify(hview, MSIMODIFY_REFRESH, hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 7, "Expected 7, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 10, "Expected 10, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
}
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
static BOOL create_storage(LPCSTR name)
|
|
|
|
{
|
|
|
|
WCHAR nameW[MAX_PATH];
|
|
|
|
IStorage *stg;
|
|
|
|
IStream *stm;
|
|
|
|
HRESULT hr;
|
|
|
|
DWORD count;
|
|
|
|
BOOL res = FALSE;
|
|
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, name, -1, nameW, MAX_PATH);
|
|
|
|
hr = StgCreateDocfile(nameW, STGM_CREATE | STGM_READWRITE |
|
|
|
|
STGM_DIRECT | STGM_SHARE_EXCLUSIVE, 0, &stg);
|
|
|
|
if (FAILED(hr))
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
hr = IStorage_CreateStream(stg, nameW, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
|
|
|
|
0, 0, &stm);
|
|
|
|
if (FAILED(hr))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
hr = IStream_Write(stm, "stgdata", 8, &count);
|
|
|
|
if (SUCCEEDED(hr))
|
|
|
|
res = TRUE;
|
|
|
|
|
|
|
|
done:
|
|
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2008-07-09 11:34:20 +00:00
|
|
|
static void test_storages_table(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
2008-12-28 10:25:32 +00:00
|
|
|
IStorage *stg, *inner;
|
|
|
|
IStream *stm;
|
2008-07-09 11:34:20 +00:00
|
|
|
char file[MAX_PATH];
|
|
|
|
char buf[MAX_PATH];
|
2008-12-28 10:25:32 +00:00
|
|
|
WCHAR name[MAX_PATH];
|
|
|
|
LPCSTR query;
|
|
|
|
HRESULT hr;
|
2008-07-09 11:34:20 +00:00
|
|
|
DWORD size;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
r = MsiDatabaseCommit(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS , "Failed to commit database\n");
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb);
|
2008-07-09 11:34:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS , "Failed to open database\n");
|
|
|
|
|
|
|
|
/* check the column types */
|
|
|
|
hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_TYPES);
|
|
|
|
ok(hrec, "failed to get column info hrecord\n");
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(check_record(hrec, 1, "s62"), "wrong hrecord type\n");
|
|
|
|
ok(check_record(hrec, 2, "V0"), "wrong hrecord type\n");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* now try the names */
|
|
|
|
hrec = get_column_info(hdb, "SELECT * FROM `_Storages`", MSICOLINFO_NAMES);
|
|
|
|
ok(hrec, "failed to get column info hrecord\n");
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(check_record(hrec, 1, "Name"), "wrong hrecord type\n");
|
|
|
|
ok(check_record(hrec, 2, "Data"), "wrong hrecord type\n");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
create_storage("storage.bin");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
hrec = MsiCreateRecord(2);
|
2014-04-23 14:49:34 +00:00
|
|
|
MsiRecordSetStringA(hrec, 1, "stgname");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordSetStreamA(hrec, 2, "storage.bin");
|
2008-07-09 11:34:20 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to add stream data to the hrecord: %d\n", r);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
DeleteFileA("storage.bin");
|
2008-07-09 11:34:20 +00:00
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
query = "INSERT INTO `_Storages` (`Name`, `Data`) VALUES (?, ?)";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
r = MsiViewExecute(hview, hrec);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
2008-12-28 10:25:32 +00:00
|
|
|
MsiViewClose(hview);
|
2008-07-09 11:34:20 +00:00
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
query = "SELECT `Name`, `Data` FROM `_Storages`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to open database hview: %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
r = MsiViewExecute(hview, 0);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to execute hview: %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to fetch hrecord: %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, file, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to get string: %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(file, "stgname"), "Expected \"stgname\", got \"%s\"\n", file);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "apple");
|
|
|
|
r = MsiRecordReadStream(hrec, 2, buf, &size);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_INVALID_DATA, "Expected ERROR_INVALID_DATA, got %d\n", r);
|
2014-04-23 14:49:34 +00:00
|
|
|
ok(!lstrcmpA(buf, "apple"), "Expected buf to be unchanged, got %s\n", buf);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(size == 0, "Expected 0, got %d\n", size);
|
2008-07-09 11:34:20 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
MsiDatabaseCommit(hdb);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, msifile, -1, name, MAX_PATH);
|
|
|
|
hr = StgOpenStorage(name, NULL, STGM_DIRECT | STGM_READ |
|
|
|
|
STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
ok(stg != NULL, "Expected non-NULL storage\n");
|
|
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "stgname", -1, name, MAX_PATH);
|
|
|
|
hr = IStorage_OpenStorage(stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE,
|
|
|
|
NULL, 0, &inner);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
ok(inner != NULL, "Expected non-NULL storage\n");
|
|
|
|
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, "storage.bin", -1, name, MAX_PATH);
|
|
|
|
hr = IStorage_OpenStream(inner, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
ok(stm != NULL, "Expected non-NULL stream\n");
|
|
|
|
|
|
|
|
hr = IStream_Read(stm, buf, MAX_PATH, &size);
|
|
|
|
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
|
|
|
|
ok(size == 8, "Expected 8, got %d\n", size);
|
|
|
|
ok(!lstrcmpA(buf, "stgdata"), "Expected \"stgdata\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(inner);
|
|
|
|
|
|
|
|
IStorage_Release(stg);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_dbtopackage(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hpkg;
|
2012-01-21 17:21:57 +00:00
|
|
|
CHAR package[12], buf[MAX_PATH];
|
2008-12-28 10:25:32 +00:00
|
|
|
DWORD size;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
/* create an empty database, transact mode */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to create database\n");
|
|
|
|
|
|
|
|
set_summary_info(hdb);
|
|
|
|
|
|
|
|
r = create_directory_table(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = create_custom_action_table(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
sprintf(package, "#%u", hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenPackageA(package, &hpkg);
|
2012-01-21 17:21:57 +00:00
|
|
|
if (r == ERROR_INSTALL_PACKAGE_REJECTED)
|
|
|
|
{
|
|
|
|
skip("Not enough rights to perform tests\n");
|
|
|
|
goto error;
|
|
|
|
}
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is not set yet */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 0, "Expected 0, got %d\n", size);
|
|
|
|
|
|
|
|
/* run the custom action to set the property */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDoActionA(hpkg, "SetProp");
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is now set */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 5, "Expected 5, got %d\n", size);
|
|
|
|
|
|
|
|
MsiCloseHandle(hpkg);
|
|
|
|
|
|
|
|
/* reset the package */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenPackageA(package, &hpkg);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is not set anymore */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-07-09 11:34:20 +00:00
|
|
|
todo_wine
|
|
|
|
{
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 0, "Expected 0, got %d\n", size);
|
2008-07-09 11:34:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
MsiCloseHandle(hpkg);
|
|
|
|
|
|
|
|
/* create an empty database, direct mode */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATEDIRECT, &hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Failed to create database\n");
|
|
|
|
|
|
|
|
set_summary_info(hdb);
|
|
|
|
|
|
|
|
r = create_directory_table(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = create_custom_action_table(hdb);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = add_custom_action_entry(hdb, "'SetProp', 51, 'MYPROP', 'grape'");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
sprintf(package, "#%u", hdb);
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenPackageA(package, &hpkg);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is not set yet */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 0, "Expected 0, got %d\n", size);
|
|
|
|
|
|
|
|
/* run the custom action to set the property */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDoActionA(hpkg, "SetProp");
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is now set */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "grape"), "Expected \"grape\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 5, "Expected 5, got %d\n", size);
|
|
|
|
|
|
|
|
MsiCloseHandle(hpkg);
|
|
|
|
|
|
|
|
/* reset the package */
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenPackageA(package, &hpkg);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* property is not set anymore */
|
|
|
|
size = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiGetPropertyA(hpkg, "MYPROP", buf, &size);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
todo_wine
|
|
|
|
{
|
|
|
|
ok(!lstrcmpA(buf, ""), "Expected \"\", got \"%s\"\n", buf);
|
|
|
|
ok(size == 0, "Expected 0, got %d\n", size);
|
|
|
|
}
|
|
|
|
|
|
|
|
MsiCloseHandle(hpkg);
|
2012-01-21 17:21:57 +00:00
|
|
|
|
|
|
|
error:
|
|
|
|
MsiCloseHandle(hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_droptable(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, hview, hrec;
|
|
|
|
CHAR buf[MAX_PATH];
|
|
|
|
LPCSTR query;
|
|
|
|
DWORD size;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "A"), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS,
|
|
|
|
"Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "DROP `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
hview = 0;
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED,
|
|
|
|
"Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `IDontExist`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE One";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `B` INT, `C` INT PRIMARY KEY `B` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "B"), "Expected \"B\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 3, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "C"), "Expected \"C\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS,
|
|
|
|
"Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "DROP TABLE One";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Tables` WHERE `Name` = 'One'";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'One'";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_dbmerge(void)
|
|
|
|
{
|
2014-04-23 14:49:34 +00:00
|
|
|
static const WCHAR refdbW[] = {'r','e','f','d','b','.','m','s','i',0};
|
2008-12-28 10:25:32 +00:00
|
|
|
MSIHANDLE hdb, href, hview, hrec;
|
|
|
|
CHAR buf[MAX_PATH];
|
|
|
|
LPCSTR query;
|
|
|
|
DWORD size;
|
|
|
|
UINT r;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(msifileW, MSIDBOPEN_CREATE, &hdb);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW(refdbW, MSIDBOPEN_CREATE, &href);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* hDatabase is invalid */
|
|
|
|
r = MsiDatabaseMergeA(0, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_INVALID_HANDLE,
|
|
|
|
"Expected ERROR_INVALID_HANDLE, got %d\n", r);
|
|
|
|
|
|
|
|
/* hDatabaseMerge is invalid */
|
|
|
|
r = MsiDatabaseMergeA(hdb, 0, "MergeErrors");
|
|
|
|
ok(r == ERROR_INVALID_HANDLE,
|
|
|
|
"Expected ERROR_INVALID_HANDLE, got %d\n", r);
|
|
|
|
|
|
|
|
/* szTableName is NULL */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, NULL);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* szTableName is empty */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "");
|
|
|
|
ok(r == ERROR_INVALID_TABLE, "Expected ERROR_INVALID_TABLE, got %d\n", r);
|
|
|
|
|
|
|
|
/* both DBs empty, szTableName is valid */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` CHAR(72) PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* column types don't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_DATATYPE_MISMATCH,
|
|
|
|
"Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2009-10-25 11:06:38 +00:00
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` CHAR(72), "
|
|
|
|
"`B` CHAR(56), "
|
|
|
|
"`C` CHAR(64) LOCALIZABLE, "
|
|
|
|
"`D` LONGCHAR, "
|
|
|
|
"`E` CHAR(72) NOT NULL, "
|
|
|
|
"`F` CHAR(56) NOT NULL, "
|
|
|
|
"`G` CHAR(64) NOT NULL LOCALIZABLE, "
|
|
|
|
"`H` LONGCHAR NOT NULL "
|
|
|
|
"PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` CHAR(64), "
|
|
|
|
"`B` CHAR(64), "
|
|
|
|
"`C` CHAR(64), "
|
|
|
|
"`D` CHAR(64), "
|
|
|
|
"`E` CHAR(64) NOT NULL, "
|
|
|
|
"`F` CHAR(64) NOT NULL, "
|
|
|
|
"`G` CHAR(64) NOT NULL, "
|
|
|
|
"`H` CHAR(64) NOT NULL "
|
|
|
|
"PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* column sting types don't match exactly */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS,
|
|
|
|
"Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `C` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* column names don't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_DATATYPE_MISMATCH,
|
|
|
|
"Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `B` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* primary keys don't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_DATATYPE_MISMATCH,
|
|
|
|
"Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A`, `B` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* number of primary keys doesn't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_DATATYPE_MISMATCH,
|
|
|
|
"Expected ERROR_DATATYPE_MISMATCH, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* number of columns doesn't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 3);
|
|
|
|
ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT, `C` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* number of columns doesn't match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 3);
|
|
|
|
ok(r == MSI_NULL_INTEGER, "Expected MSI_NULL_INTEGER, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 1 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 2 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 2 )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 3 )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* primary keys match, rows do not */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED,
|
|
|
|
"Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "One"), "Expected \"One\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, "SELECT * FROM `MergeErrors`", &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(hview, MSICOLINFO_NAMES, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(!lstrcmpA(buf, "Table"), "Expected \"Table\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(!lstrcmpA(buf, "NumRowMergeConflicts"),
|
|
|
|
"Expected \"NumRowMergeConflicts\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(hview, MSICOLINFO_TYPES, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(!lstrcmpA(buf, "s255"), "Expected \"s255\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-12-28 10:25:32 +00:00
|
|
|
ok(!lstrcmpA(buf, "i2"), "Expected \"i2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
|
|
|
query = "DROP TABLE `MergeErrors`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
2009-06-06 15:59:11 +00:00
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* table from merged database is not in target database */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` CHAR(72), `B` INT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 'hi', 1 )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* primary key is string */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 1, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
create_file_data("codepage.idt", "\r\n\r\n850\t_ForceCodepage\r\n", 0);
|
|
|
|
|
|
|
|
GetCurrentDirectoryA(MAX_PATH, buf);
|
|
|
|
r = MsiDatabaseImportA(hdb, buf, "codepage.idt");
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2008-12-28 10:25:32 +00:00
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( "
|
|
|
|
"`A` INT, `B` CHAR(72) LOCALIZABLE PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'hi' )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* code page does not match */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "hi"), "Expected \"hi\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` OBJECT PRIMARY KEY `A` )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
create_file("binary.dat");
|
|
|
|
hrec = MsiCreateRecord(1);
|
|
|
|
MsiRecordSetStreamA(hrec, 1, "binary.dat");
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, ? )";
|
|
|
|
r = run_query(href, hrec, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* binary data to merge */
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
ZeroMemory(buf, MAX_PATH);
|
|
|
|
r = MsiRecordReadStream(hrec, 2, buf, &size);
|
2009-06-06 15:59:11 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "binary.dat\n"),
|
|
|
|
"Expected \"binary.dat\\n\", got \"%s\"\n", buf);
|
2008-12-28 10:25:32 +00:00
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
/* nothing in MergeErrors */
|
|
|
|
query = "SELECT * FROM `MergeErrors`";
|
|
|
|
r = do_query(hdb, query, &hrec);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
2009-10-25 11:06:38 +00:00
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "DROP TABLE `One`";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `One` ( `A` INT, `B` CHAR(72) PRIMARY KEY `A` )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 1, 'foo' )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `One` ( `A`, `B` ) VALUES ( 2, 'bar' )";
|
|
|
|
r = run_query(href, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiDatabaseMergeA(hdb, href, "MergeErrors");
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `One`";
|
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &hview);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
r = MsiViewExecute(hview, 0);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "foo"), "Expected \"foo\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(hrec, 1);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
size = MAX_PATH;
|
|
|
|
r = MsiRecordGetStringA(hrec, 2, buf, &size);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA(buf, "bar"), "Expected \"bar\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(hrec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(hview, &hrec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS,
|
|
|
|
"Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
|
|
|
MsiViewClose(hview);
|
|
|
|
MsiCloseHandle(hview);
|
|
|
|
|
2008-12-28 10:25:32 +00:00
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
MsiCloseHandle(href);
|
|
|
|
DeleteFileA(msifile);
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileW(refdbW);
|
2008-12-28 10:25:32 +00:00
|
|
|
DeleteFileA("codepage.idt");
|
|
|
|
DeleteFileA("binary.dat");
|
2008-07-09 11:34:20 +00:00
|
|
|
}
|
|
|
|
|
2009-12-06 14:46:53 +00:00
|
|
|
static void test_select_with_tablenames(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, view, rec;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT r;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
int vals[4][2] = {
|
|
|
|
{1,12},
|
|
|
|
{4,12},
|
|
|
|
{1,15},
|
|
|
|
{4,15}};
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
/* Build a pair of tables with the same column names, but unique data */
|
|
|
|
query = "CREATE TABLE `T1` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 1, 2 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T1` ( `A`, `B` ) VALUES ( 4, 5 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T2` ( `A` SHORT, `B` SHORT PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 11, 12 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T2` ( `A`, `B` ) VALUES ( 14, 15 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
|
|
|
|
/* Test that selection based on prefixing the column with the table
|
|
|
|
* actually selects the right data */
|
|
|
|
|
|
|
|
query = "SELECT T1.A, T2.B FROM T1,T2";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-12-06 14:46:53 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
{
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == vals[i][0], "Expected %d, got %d\n", vals[i][0], r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == vals[i][1], "Expected %d, got %d\n", vals[i][1], r);
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
static const UINT ordervals[6][3] =
|
2009-05-17 07:05:22 +00:00
|
|
|
{
|
|
|
|
{ MSI_NULL_INTEGER, 12, 13 },
|
|
|
|
{ 1, 2, 3 },
|
|
|
|
{ 6, 4, 5 },
|
|
|
|
{ 8, 9, 7 },
|
|
|
|
{ 10, 11, MSI_NULL_INTEGER },
|
|
|
|
{ 14, MSI_NULL_INTEGER, 15 }
|
|
|
|
};
|
|
|
|
|
|
|
|
static void test_insertorder(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, view, rec;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT r;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T` ( `A` SHORT, `B` SHORT, `C` SHORT PRIMARY KEY `A`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `A`, `B`, `C` ) VALUES ( 1, 2, 3 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `B`, `C`, `A` ) VALUES ( 4, 5, 6 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `C`, `A`, `B` ) VALUES ( 7, 8, 9 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `A`, `B` ) VALUES ( 10, 11 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
/* fails because the primary key already
|
|
|
|
* has an MSI_NULL_INTEGER value set above
|
|
|
|
*/
|
|
|
|
query = "INSERT INTO `T` ( `C` ) VALUES ( 14 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED,
|
|
|
|
"Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
|
|
|
|
/* replicate the error where primary key is set twice */
|
|
|
|
query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 1, 14 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_FUNCTION_FAILED,
|
|
|
|
"Expected ERROR_FUNCTION_FAILED, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `A`, `C` ) VALUES ( 14, 15 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` VALUES ( 16 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` VALUES ( 17, 18 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` VALUES ( 19, 20, 21 )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_BAD_QUERY_SYNTAX,
|
|
|
|
"Expected ERROR_BAD_QUERY_SYNTAX, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `T`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
for (i = 0; i < 6; i++)
|
|
|
|
{
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 3);
|
|
|
|
ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
2009-08-08 12:48:20 +00:00
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "DELETE FROM `T` WHERE `A` IS NULL";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `B`, `C` ) VALUES ( 12, 13 ) TEMPORARY";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `T`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-08-08 12:48:20 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
for (i = 0; i < 6; i++)
|
|
|
|
{
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == ordervals[i][0], "Expected %d, got %d\n", ordervals[i][0], r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == ordervals[i][1], "Expected %d, got %d\n", ordervals[i][1], r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 3);
|
|
|
|
ok(r == ordervals[i][2], "Expected %d, got %d\n", ordervals[i][2], r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_NO_MORE_ITEMS, "Expected ERROR_NO_MORE_ITEMS, got %d\n", r);
|
|
|
|
|
2009-05-17 07:05:22 +00:00
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
MsiCloseHandle(hdb);
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_columnorder(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, view, rec;
|
|
|
|
char buf[MAX_PATH];
|
|
|
|
LPCSTR query;
|
|
|
|
DWORD sz;
|
|
|
|
UINT r;
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
/* Each column is a slot:
|
|
|
|
* ---------------------
|
|
|
|
* | B | C | A | E | D |
|
|
|
|
* ---------------------
|
|
|
|
*
|
|
|
|
* When a column is selected as a primary key,
|
|
|
|
* the column occupying the nth primary key slot is swapped
|
|
|
|
* with the current position of the primary key in question:
|
|
|
|
*
|
|
|
|
* set primary key `D`
|
|
|
|
* --------------------- ---------------------
|
|
|
|
* | B | C | A | E | D | -> | D | C | A | E | B |
|
|
|
|
* --------------------- ---------------------
|
|
|
|
*
|
|
|
|
* set primary key `E`
|
|
|
|
* --------------------- ---------------------
|
|
|
|
* | D | C | A | E | B | -> | D | E | A | C | B |
|
|
|
|
* --------------------- ---------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
query = "CREATE TABLE `T` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
|
|
|
|
"`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
|
|
|
|
"PRIMARY KEY `D`, `E`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `T`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 4, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 5, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 4, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 5, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "INSERT INTO `T` ( `B`, `C`, `A`, `E`, `D` ) "
|
|
|
|
"VALUES ( 1, 2, 'a', 3, 'bc' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `T`";
|
|
|
|
r = do_query(hdb, query, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2009-05-17 07:05:22 +00:00
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 4);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 5);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 4, "Expected 4, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
query = "CREATE TABLE `Z` ( `B` SHORT NOT NULL, `C` SHORT NOT NULL, "
|
|
|
|
"`A` CHAR(255), `E` INT, `D` CHAR(255) NOT NULL "
|
|
|
|
"PRIMARY KEY `C`, `A`, `D`)";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Z`";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_TYPES, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("S255", buf), "Expected \"S255\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("s255", buf), "Expected \"s255\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 4, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("I2", buf), "Expected \"I2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 5, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("i2", buf), "Expected \"i2\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewGetColumnInfo(view, MSICOLINFO_NAMES, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 4, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 5, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
MsiViewClose(view);
|
|
|
|
MsiCloseHandle(view);
|
|
|
|
|
|
|
|
query = "INSERT INTO `Z` ( `B`, `C`, `A`, `E`, `D` ) "
|
|
|
|
"VALUES ( 1, 2, 'a', 3, 'bc' )";
|
|
|
|
r = run_query(hdb, 0, query);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `Z`";
|
|
|
|
r = do_query(hdb, query, &rec);
|
2012-01-21 17:21:57 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
2009-05-17 07:05:22 +00:00
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 1);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 2, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("a", buf), "Expected \"a\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("bc", buf), "Expected \"bc\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 4);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 5);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `_Columns` WHERE `Table` = 'T'";
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA(hdb, query, &view);
|
2009-05-17 07:05:22 +00:00
|
|
|
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);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 1, "Expected 1, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("D", buf), "Expected \"D\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 2, "Expected 2, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("E", buf), "Expected \"E\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 3, "Expected 3, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("A", buf), "Expected \"A\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 4, "Expected 4, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("C", buf), "Expected \"C\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
MsiCloseHandle(rec);
|
|
|
|
|
|
|
|
r = MsiViewFetch(view, &rec);
|
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 1, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("T", buf), "Expected \"T\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
r = MsiRecordGetInteger(rec, 2);
|
|
|
|
ok(r == 5, "Expected 5, got %d\n", r);
|
|
|
|
|
|
|
|
sz = MAX_PATH;
|
|
|
|
lstrcpyA(buf, "kiwi");
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiRecordGetStringA(rec, 3, buf, &sz);
|
2009-05-17 07:05:22 +00:00
|
|
|
ok(r == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", r);
|
|
|
|
ok(!lstrcmpA("B", buf), "Expected \"B\", got \"%s\"\n", buf);
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
static void test_createtable(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb, htab = 0, hrec = 0;
|
|
|
|
LPCSTR query;
|
|
|
|
UINT res;
|
|
|
|
DWORD size;
|
|
|
|
char buffer[0x20];
|
|
|
|
|
|
|
|
hdb = create_db();
|
|
|
|
ok(hdb, "failed to create db\n");
|
|
|
|
|
|
|
|
query = "CREATE TABLE `blah` (`foo` CHAR(72) NOT NULL PRIMARY KEY `foo`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiDatabaseOpenViewA( hdb, query, &htab );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
if(res == ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
res = MsiViewExecute( htab, hrec );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
|
|
|
|
todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
size = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiRecordGetStringA(hrec, 1, buffer, &size );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
todo_wine ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
2012-01-21 17:21:57 +00:00
|
|
|
MsiCloseHandle( hrec );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
|
|
|
|
res = MsiViewClose( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
}
|
|
|
|
|
|
|
|
query = "CREATE TABLE `a` (`b` INT PRIMARY KEY `b`)";
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiDatabaseOpenViewA( hdb, query, &htab );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
if(res == ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
res = MsiViewExecute( htab, 0 );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiViewClose( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `a`";
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiDatabaseOpenViewA( hdb, query, &htab );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
buffer[0] = 0;
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
size = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiRecordGetStringA(hrec, 1, buffer, &size );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
|
2012-01-21 17:21:57 +00:00
|
|
|
MsiCloseHandle( hrec );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
|
|
|
|
res = MsiViewClose( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiDatabaseCommit(hdb);
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle(hdb);
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiOpenDatabaseW(msifileW, MSIDBOPEN_TRANSACT, &hdb );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
query = "SELECT * FROM `a`";
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiDatabaseOpenViewA( hdb, query, &htab );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiViewGetColumnInfo( htab, MSICOLINFO_NAMES, &hrec );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
buffer[0] = 0;
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
size = sizeof(buffer);
|
2014-04-23 14:49:34 +00:00
|
|
|
res = MsiRecordGetStringA(hrec, 1, buffer, &size );
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
2012-08-13 16:18:14 +00:00
|
|
|
ok(!strcmp(buffer,"b"), "b != %s\n", buffer);
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
|
|
|
|
res = MsiCloseHandle( hrec );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiViewClose( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle( htab );
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
}
|
|
|
|
|
|
|
|
res = MsiDatabaseCommit(hdb);
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
res = MsiCloseHandle(hdb);
|
|
|
|
ok(res == ERROR_SUCCESS, "Expected ERROR_SUCCESS, got %d\n", res);
|
|
|
|
|
|
|
|
DeleteFileA(msifile);
|
|
|
|
}
|
|
|
|
|
2012-01-21 17:21:57 +00:00
|
|
|
static void test_embedded_nulls(void)
|
|
|
|
{
|
|
|
|
static const char control_table[] =
|
|
|
|
"Dialog\tText\n"
|
|
|
|
"s72\tL0\n"
|
|
|
|
"Control\tDialog\n"
|
|
|
|
"LicenseAgreementDlg\ttext\x11\x19text\0text";
|
|
|
|
UINT r, sz;
|
|
|
|
MSIHANDLE hdb, hrec;
|
|
|
|
char buffer[32];
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
|
2012-01-21 17:21:57 +00:00
|
|
|
ok( r == ERROR_SUCCESS, "failed to open database %u\n", r );
|
|
|
|
|
|
|
|
GetCurrentDirectoryA( MAX_PATH, CURR_DIR );
|
|
|
|
write_file( "temp_file", control_table, sizeof(control_table) );
|
|
|
|
r = MsiDatabaseImportA( hdb, CURR_DIR, "temp_file" );
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to import table %u\n", r );
|
|
|
|
DeleteFileA( "temp_file" );
|
|
|
|
|
|
|
|
r = do_query( hdb, "SELECT `Text` FROM `Control` WHERE `Dialog` = 'LicenseAgreementDlg'", &hrec );
|
|
|
|
ok( r == ERROR_SUCCESS, "query failed %u\n", r );
|
|
|
|
|
|
|
|
buffer[0] = 0;
|
|
|
|
sz = sizeof(buffer);
|
|
|
|
r = MsiRecordGetStringA( hrec, 1, buffer, &sz );
|
|
|
|
ok( r == ERROR_SUCCESS, "failed to get string %u\n", r );
|
|
|
|
ok( !memcmp( "text\r\ntext\ntext", buffer, sizeof("text\r\ntext\ntext") - 1 ), "wrong buffer contents \"%s\"\n", buffer );
|
|
|
|
|
|
|
|
MsiCloseHandle( hrec );
|
|
|
|
MsiCloseHandle( hdb );
|
|
|
|
DeleteFileA( msifile );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_select_column_names(void)
|
|
|
|
{
|
|
|
|
MSIHANDLE hdb = 0, rec, rec2, view;
|
|
|
|
char buffer[32];
|
|
|
|
UINT r, size;
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
DeleteFileA(msifile);
|
2012-01-21 17:21:57 +00:00
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiOpenDatabaseW( msifileW, MSIDBOPEN_CREATE, &hdb );
|
2012-01-21 17:21:57 +00:00
|
|
|
ok( r == ERROR_SUCCESS , "failed to open database: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "CREATE TABLE `t` (`a` CHAR NOT NULL, `b` CHAR PRIMARY KEY `a`)");
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `t`.`b` FROM `t` WHERE `t`.`b` = `x`" );
|
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT '', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT *, `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
todo_wine ok( r == ERROR_SUCCESS, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT 'b', `t`.`b` FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY `b`" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `t`.`b`, '' FROM `t` WHERE `t`.`b` = 'x' ORDER BY 'b'" );
|
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT 't'.'b' FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT 'b' FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '1', '2' )" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "INSERT INTO `t` ( `a`, `b` ) VALUES( '3', '4' )" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, "SELECT '' FROM `t`", &view );
|
2012-01-21 17:21:57 +00:00
|
|
|
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 );
|
|
|
|
r = MsiRecordGetFieldCount( rec );
|
|
|
|
ok( r == 1, "got %u\n", r );
|
|
|
|
r = MsiViewGetColumnInfo( view, MSICOLINFO_NAMES, &rec2 );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
r = MsiRecordGetFieldCount( rec2 );
|
|
|
|
ok( r == 1, "got %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec2, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec2 );
|
|
|
|
r = MsiViewGetColumnInfo( view, MSICOLINFO_TYPES, &rec2 );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
r = MsiRecordGetFieldCount( rec2 );
|
|
|
|
ok( r == 1, "got %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec2, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "f0" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec2 );
|
|
|
|
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '' FROM `t`", &view );
|
2012-01-21 17:21:57 +00:00
|
|
|
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 );
|
|
|
|
r = MsiRecordGetFieldCount( rec );
|
|
|
|
ok( r == 2, "got %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 2, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, "SELECT '', `a` FROM `t`", &view );
|
2012-01-21 17:21:57 +00:00
|
|
|
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 );
|
|
|
|
r = MsiRecordGetFieldCount( rec );
|
|
|
|
ok( r == 2, "got %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 2, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 2, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
2014-04-23 14:49:34 +00:00
|
|
|
r = MsiDatabaseOpenViewA( hdb, "SELECT `a`, '', `b` FROM `t`", &view );
|
2012-01-21 17:21:57 +00:00
|
|
|
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 );
|
|
|
|
r = MsiRecordGetFieldCount( rec );
|
|
|
|
ok( r == 3, "got %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "1" ), "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 2, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 3, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "2" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 1, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "3" ), "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 2, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !buffer[0], "got \"%s\"\n", buffer );
|
|
|
|
size = sizeof(buffer);
|
|
|
|
memset( buffer, 0x55, sizeof(buffer) );
|
|
|
|
r = MsiRecordGetStringA( rec, 3, buffer, &size );
|
|
|
|
ok( r == ERROR_SUCCESS, "unexpected result: %u\n", r );
|
|
|
|
ok( !lstrcmpA( buffer, "4" ), "got \"%s\"\n", buffer );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
r = MsiViewFetch( view, &rec );
|
|
|
|
ok( r == ERROR_NO_MORE_ITEMS, "unexpected result: %u\n", r );
|
|
|
|
MsiCloseHandle( rec );
|
|
|
|
|
|
|
|
MsiViewClose( view );
|
|
|
|
MsiCloseHandle( view );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT '' FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_SUCCESS , "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `` FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `b` FROM 't' WHERE `t`.`b` = 'x'" );
|
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `b` FROM `t` WHERE 'b' = 'x'" );
|
|
|
|
ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = try_query( hdb, "SELECT `t`.`b`, `` FROM `t` WHERE `t`.`b` = 'x'" );
|
|
|
|
todo_wine ok( r == ERROR_BAD_QUERY_SYNTAX, "query failed: %u\n", r );
|
|
|
|
|
|
|
|
r = MsiCloseHandle( hdb );
|
|
|
|
ok(r == ERROR_SUCCESS , "failed to close database: %u\n", r);
|
|
|
|
}
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
|
2007-03-06 11:59:18 +00:00
|
|
|
START_TEST(db)
|
|
|
|
{
|
|
|
|
test_msidatabase();
|
|
|
|
test_msiinsert();
|
|
|
|
test_msidecomposedesc();
|
|
|
|
test_msibadqueries();
|
|
|
|
test_viewmodify();
|
|
|
|
test_viewgetcolumninfo();
|
|
|
|
test_getcolinfo();
|
|
|
|
test_msiexport();
|
|
|
|
test_longstrings();
|
|
|
|
test_streamtable();
|
2009-06-06 15:59:11 +00:00
|
|
|
test_binary();
|
2009-11-16 01:15:54 +00:00
|
|
|
test_where_not_in_selected();
|
2007-03-06 11:59:18 +00:00
|
|
|
test_where();
|
|
|
|
test_msiimport();
|
2009-06-06 15:59:11 +00:00
|
|
|
test_binary_import();
|
2007-03-06 11:59:18 +00:00
|
|
|
test_markers();
|
2008-02-10 13:22:36 +00:00
|
|
|
test_handle_limit();
|
|
|
|
test_try_transform();
|
|
|
|
test_join();
|
|
|
|
test_temporary_table();
|
|
|
|
test_alter();
|
|
|
|
test_integers();
|
|
|
|
test_update();
|
|
|
|
test_special_tables();
|
2009-08-08 12:48:20 +00:00
|
|
|
test_tables_order();
|
2009-10-25 11:06:38 +00:00
|
|
|
test_rows_order();
|
2008-02-10 13:22:36 +00:00
|
|
|
test_select_markers();
|
|
|
|
test_viewmodify_update();
|
2009-08-08 12:48:20 +00:00
|
|
|
test_viewmodify_assign();
|
2008-02-10 13:22:36 +00:00
|
|
|
test_stringtable();
|
|
|
|
test_viewmodify_delete();
|
|
|
|
test_defaultdatabase();
|
|
|
|
test_order();
|
|
|
|
test_viewmodify_delete_temporary();
|
|
|
|
test_deleterow();
|
|
|
|
test_quotes();
|
|
|
|
test_carriagereturn();
|
2008-04-04 16:43:16 +00:00
|
|
|
test_noquotes();
|
|
|
|
test_forcecodepage();
|
|
|
|
test_viewmodify_refresh();
|
2008-05-09 17:35:45 +00:00
|
|
|
test_where_viewmodify();
|
2008-07-09 11:34:20 +00:00
|
|
|
test_storages_table();
|
2008-12-28 10:25:32 +00:00
|
|
|
test_dbtopackage();
|
|
|
|
test_droptable();
|
|
|
|
test_dbmerge();
|
2009-12-06 14:46:53 +00:00
|
|
|
test_select_with_tablenames();
|
2009-05-17 07:05:22 +00:00
|
|
|
test_insertorder();
|
|
|
|
test_columnorder();
|
2009-06-06 15:59:11 +00:00
|
|
|
test_suminfo_import();
|
Sync advapi32, comctl32, crypt32, cryptui, cryptnet, fusion, gdi32, gdiplus, hlink, imm32, jscript, kernel32, localspl, msacm32, mscms, msi, mstask, msvcrtd, msxml3, ntdll, ole32, pdh, psapi, quartz, rasapi32, riched20 AND rsaenh Winetests.
TBD mshtml, shell32, oleaut32 which still fail to build here
svn path=/trunk/; revision=47931
2010-07-03 12:45:23 +00:00
|
|
|
test_createtable();
|
2012-01-21 17:21:57 +00:00
|
|
|
test_collation();
|
|
|
|
test_embedded_nulls();
|
|
|
|
test_select_column_names();
|
2007-03-06 11:59:18 +00:00
|
|
|
}
|