Windows/Windows-classic-samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Windows-classic-samples/Samples/Win7Samples/dataaccess/oledb_conformance/oledb/itbldef/itbldef.cpp
Raten 12d6772ad2 new
2025-11-28 00:35:46 +09:00

32839 lines
1009 KiB
C++
Raw Permalink Blame History

//--------------------------------------------------------------------
// Microsoft OLE DB Test
//
// Copyright 1995-2000 Microsoft Corporation.
//
// @doc
//
// @module ITblDef.CPP | Source for ITableDefinition test module
//
#define DBINITCONSTANTS // Must be defined to initialize constants in OLEDB.H
#define INITGUID
#include "modstandard.hpp"
#include "itbldef.h"
#include "Extralib.h"
#include <initguid.h>
#include <process.h>
#include "clib.hpp"
#include "DataSource.hpp"
const ULONG cMaxName = 300;
// maximum columns allowed per constraint
const DBORDINAL cMaxColsPerCons = 16;
// Maximum combined column length of constraint
const DBORDINAL cMaxColLengthPerCons = 900;
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Module Values
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// {{ TCW_MODULE_GLOBALS
DECLARE_MODULE_CLSID = { 0xae3d5c1e, 0x2a0b, 0x11d1, { 0xaf, 0x9d, 0x00, 0xc0, 0x4f, 0xc2, 0x27, 0x93 }};
DECLARE_MODULE_NAME("ITableDefinition");
DECLARE_MODULE_OWNER("Microsoft");
DECLARE_MODULE_DESCRIP("The module tests the ITableDefinition interface");
DECLARE_MODULE_VERSION(795921705);
// TCW_WizardVersion(2)
// TCW_Automation(True)
// }} TCW_MODULE_GLOBALS_END
GUID guidModule = { 0xae3d5c1e, 0x2a0b, 0x11d1, { 0xaf, 0x9d, 0x00, 0xc0, 0x4f, 0xc2, 0x27, 0x93 }};
//Globals
BOOL g_fSQLOLEDB25 = FALSE;
// macros
#define FILL_PROP_SET(RGPROPSET_EL, NPROP, RGPROP, PROP_GUID) \
RGPROPSET_EL.cProperties = NPROP; \
RGPROPSET_EL.rgProperties = RGPROP; \
RGPROPSET_EL.guidPropertySet = PROP_GUID; \
if (NULL != RGPROP) \
memset(RGPROP, 0, NPROP*sizeof(DBPROP));
#define FILL_PROP(RGPROP_EL, PROPID, VAR_TYPE, VAR_MACRO, VAR_VALUE, OPTION) \
memset(&RGPROP_EL, 0, sizeof(DBPROP)); \
RGPROP_EL.dwPropertyID = PROPID; \
RGPROP_EL.vValue.vt = VAR_TYPE; \
VAR_MACRO(&RGPROP_EL.vValue) = VAR_VALUE; \
RGPROP_EL.dwOptions = OPTION;
#define INVALID_DBKIND 1001
class TCITableDefinition;
class CTransactionLocal;
class CAddUniqueConsTxnAdapter;
// define argument stru for threading function parameters
typedef struct inparam{
ULONG i;
TCITableDefinition *pObject;
} CInParam;
// the number of threads that will be created in the multithreading test variations
const int nThreads = 7; // must be less than 100 and greater than 1
// the dispatcher thread function
unsigned WINAPI ThreadProc(LPVOID lpvThreadParam);
void ReleaseAllColumnPropSets(
DBCOLUMNDESC *rgColumnDesc, // [in] aray to be release
DBORDINAL cColumnDesc // [in] no of elementrs in the array
);
ULONG nResidualTables;
//--------------------------------------------------------------------
// @func Module level initialization routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleInit(CThisTestModule * pThisTestModule)
{
TBEGIN;
ITableDefinition *pITableDefinition = NULL;
HRESULT hr;
nResidualTables = 0;
//Create the session
if(!ModuleCreateDBSession(pThisTestModule))
return FALSE;
g_pIOpenRowset = (IOpenRowset*)pThisTestModule->m_pIUnknown2;
CConsDesc::s_pSessionIUnknown = g_pIOpenRowset;
CConsDesc::s_pDSOIUnknown = pThisTestModule->m_pIUnknown;
CConsDesc::s_pConstraints = new CConstraints(g_pIOpenRowset);
CConsDesc::s_fInsideTransaction = FALSE;
if (!(hr=VerifyInterface(pThisTestModule->m_pIUnknown2, IID_ITableDefinition,
SESSION_INTERFACE, (IUnknown**)&pITableDefinition)))
{
odtLog << "ITableDefinition not supported!\n";
TESTB = TEST_SKIPPED;;
goto CLEANUP;
}
if (!(hr=VerifyInterface(pThisTestModule->m_pIUnknown, IID_IDBInitialize,
DATASOURCE_INTERFACE, (IUnknown**)&g_pIDBInitialize)))
{
odtLog << "IDBInitialize not supported!\n";
TESTB = TEST_SKIPPED;
goto CLEANUP;
}
if (IsSQLProvider())
{
if (GetModInfo()->GetProviderVer() && wcsncmp(GetModInfo()->GetProviderVer(), L"07", 2)==0)
g_fSQLOLEDB25 = TRUE;
}
CLEANUP:
SAFE_RELEASE(pITableDefinition);
TRETURN;
}
//--------------------------------------------------------------------
// @func Module level termination routine
//
// @rdesc Success or Failure
// @flag TRUE | Successful initialization
// @flag FALSE | Initialization problems
//
BOOL ModuleTerminate(CThisTestModule * pThisTestModule)
{
SAFE_DELETE( CConsDesc::s_pConstraints);
CConsDesc::s_pSessionIUnknown = NULL;
CConsDesc::s_pDSOIUnknown = NULL;
if (0 < nResidualTables)
odtLog << "Total number of residual tables: " << nResidualTables << "\n";
SAFE_RELEASE(g_pIDBInitialize);
CCheckConsRowset::s_fMetadataInitialized = FALSE;
CCheckConsRowset::s_fSchemaSupported = FALSE;
CCheckConsRowset::s_fConsCatalogR = FALSE;
CCheckConsRowset::s_fConsSchemaR = FALSE;
CCheckConsRowset::s_fConsNameR = FALSE;
CPKRowset::s_fMetadataInitialized = FALSE;
CPKRowset::s_fSchemaSupported = FALSE;
CPKRowset::s_fTableCatalogR = FALSE;
CPKRowset::s_fTableSchemaR = FALSE;
CPKRowset::s_fTableNameR = FALSE;
CFKRowset::s_fMetadataInitialized = FALSE;
CFKRowset::s_fSchemaSupported = FALSE;
CFKRowset::s_fTableCatalogR = FALSE;
CFKRowset::s_fTableSchemaR = FALSE;
CFKRowset::s_fTableNameR = FALSE;
CKeyColumnUsageRowset::s_fMetadataInitialized = FALSE;
CKeyColumnUsageRowset::s_fSchemaSupported = FALSE;
CKeyColumnUsageRowset::s_fTableCatalogR = FALSE;
CKeyColumnUsageRowset::s_fTableSchemaR = FALSE;
CKeyColumnUsageRowset::s_fTableNameR = FALSE;
CKeyColumnUsageRowset::s_fConsCatalogR = FALSE;
CKeyColumnUsageRowset::s_fConsSchemaR = FALSE;
CKeyColumnUsageRowset::s_fConsNameR = FALSE;
return ModuleReleaseDBSession(pThisTestModule);
}
//--------------------------------------------------------------------------
// Given DBCOLUMNDESC, returns the Type name.
//--------------------------------------------------------------------------
WCHAR* GetColumnTypeName(DBCOLUMNDESC *pColumnDesc)
{
return pColumnDesc->pwszTypeName;
}
//--------------------------------------------------------------------------
//
// release the property of all columns
//--------------------------------------------------------------------------
void ReleaseAllColumnPropSets(
DBCOLUMNDESC *rgColumnDesc, // [in] aray to be release
DBORDINAL cColumnDesc // [in] no of elementrs in the array
)
{
ULONG i;
if ( (NULL == rgColumnDesc) ||
(0 == cColumnDesc))
return;
for (i=0; i<cColumnDesc; i++)
{
FreeProperties(&rgColumnDesc[i].cPropertySets, &rgColumnDesc[i].rgPropertySets);
ASSERT(0 == rgColumnDesc[i].cPropertySets);
ASSERT(NULL == rgColumnDesc[i].rgPropertySets);
}
} //ReleaseAllColumnPropSets
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Test Case Section
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//--------------------------------------------------------------------
// @class Base Class
//
class TCITableDefinition : public CSessionObject {
protected:
// add critical section
CRITICAL_SECTION m_CriticalSection;
// used to check for residual tables
ULONG m_nTables;
// @cmember pointer to ITableDefinition interface
ITableDefinition *m_pITableDefinition;
ITableDefinitionWithConstraints *m_pITDWC;
BOOL m_fIsIDBInfo;
// @cmember list of CCol storing info about provider data types
CList <CCol, CCol&> m_ColList;
// @cmember data about table and column name
ULONG m_cMaxTableName, m_cMaxColName;
LPOLESTR m_pwszInvalidTableChars;
LPOLESTR m_pwszInvalidColChars;
// @cmember array of column descriptors on the table (limited operations on it)
DBCOLUMNDESC *m_rgColumnDesc;
DBORDINAL m_cColumnDesc;
// @cmembe aray of result for multithreading processing
HRESULT m_rgResult[nThreads];
// @cmember array of table name for multithreading
LPWSTR m_rgName[nThreads];
DBMATCHTYPE m_SupportedMatchType;
// @cmember Check the result and property status
BOOL CheckPropertyStatus(
GUID guidPropertySet, // [in] property set guid
GUID guidExpectedPS, // [in] expected prop set guid
DBPROP *pProp, // [in] property
HRESULT hr // [in] the result
);
// @cmember Check the prop status of a list of col desc
BOOL CheckColPropStatus(
DBORDINAL cColDesc, // [in]
DBCOLUMNDESC *rgColDesc, // [in] the size of the propset array
HRESULT hr // [in] the result of the previous op
);
// @cmember Drops the column and checks the result
HRESULT DropColumnAndCheck(
DBID *pTableID, // [in] the table ID
DBID *pColumnID, // [in] the ID of the column to be dropped
ITableDefinition *pITableDefinition = NULL, // [in] pointer to ITableDefinition interface
DBID *pBaseTableID = NULL // [in] if pTableID is exotic (e.g. fuly qualified) use this
);
// @cmember Drops the table and checks the result
HRESULT DropTableAndCheck(
DBID *pTableID, // [in] ID of the table to be dropped
ITableDefinition *pITableDefinition = NULL // [in] pointer to ITableDefinition interface
);
// @cmember Gets literal info about tables and columns
HRESULT GetLiteralInfo();
// @cmember Gets the catalog and schema name for a given table
BOOL GetCatalogSchemaNames(
LPWSTR pwszTableName, // [in] the name of the table
LPWSTR *ppwszCatalogName, // [out] catalog name
LPWSTR *ppwszSchemaName, // [out] schema name
CTable *pTable = NULL // [in] table object (DEFAULT NULL - use m_pTable)
);
// @cmember Check whether the array of ColumnDesc sent was preserved
// all the data should be inside, the only thing that is allowed to be modified <nl>
// is the property status
BOOL IsColumnDescPreserved
(
DBCOLUMNDESC *rgInColumnDesc, // the array passed to ITableDefinition
DBCOLUMNDESC *rgOutColumnDesc, // the aray returned by ITableDefinition
DBORDINAL cColumnDesc // the size of the arrays
);
// @cmember Build a valid table name of a certain length
WCHAR* BuildValidName(size_t, WCHAR*);
// @cmember Build an invalid table name of a certain length
WCHAR* BuildInvalidName(size_t, WCHAR*, WCHAR*);
// @cmember Uses m_pTable to get a column description mentioning all the provider types
void GetProviderTypes(void);
// @cmember Passes a type name and retrieves the column from m_ColList with info about that type
CCol GetType(WCHAR *pwszTypeName, DBTYPE wType, BOOL *fExists=NULL);
// @cmember Sets all the columns to maximum size as got from m_ColList (from PROVIDER_TYPES Rowset)
BOOL SetMaximumColSize(DBCOLUMNDESC*, DBORDINAL);
// @cmember Sets all the column sizes to 0
BOOL SetZeroColSize(DBCOLUMNDESC*, DBORDINAL);
// @cmember Set a default property in the property sets of a DBCOLUMNDESC
BOOL SetDefaultProperty(
DBPROPSET **prgPropertySets, // [in/out] array of property sets
ULONG *pcPropertySets, // [in/out] number of property sets
VARIANT *pvalue, // [in] property value
DBPROPOPTIONS dwOption = DBPROPOPTIONS_OPTIONAL, // [in] prop options
DBID colid = DB_NULLID, // [in] col id
GUID guidPropertySet = DBPROPSET_COLUMN, // [in] the GUID of the propset
ULONG *pcPropSet = NULL, // [out] index of property set
ULONG *pcProp =NULL // [out] index in the rgProperties array
);
// @cmember Compare the list of old columns against the list of new columns and the new column
BOOL CheckColInfo(DBCOLUMNDESC*, DBORDINAL, DBCOLUMNDESC*, DBORDINAL, DBCOLUMNDESC*);
// @cmember Compare the list of old columns against the list of new columns
BOOL AreColEqual(DBCOLUMNDESC*, DBORDINAL, DBCOLUMNDESC*, DBORDINAL);
// @cmember CheckReturnedDBID about the columns in the table
// pIndexID - [IN] the DBID asked for
// ppIndexID - [IN] the DBID created
BOOL CheckReturnedDBID(
DBID *pIndexID, // passed to CreateIndex
DBID **ppIndexID // returned by CreateIndex
);
// @member Add a column using ITableDefinition::AddColumn and check its addition
HRESULT AddColumnAndCheck(
DBID *pTableID, // [IN] table ID
DBCOLUMNDESC *pColumnDesc, // [IN] descriptor of the column to be added
DBID **ppColumnID, // [OUT] column ID for the resulted column
ITableDefinition *pITableDefinition = NULL, // [IN] pointer to ITableDefinition
DBID *pBaseTableID = NULL
);
// @member Check properties on rowseet and table
BOOL CheckRwstTblPropStatus(
ULONG cPropSet, // [in] the size of the propset array
DBPROPSET *rgPropSet, // [in] propset array
HRESULT hr // [in] the result of the previous op
);
// @member Create the table using ITableDefinition::CreateTable and check its creation
// then drops the table
HRESULT CCNDropTable(
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDesc, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
BOOL fNullPPTableID = FALSE // [in] if TRUE ppTableID will be NULL
);
// @cmember Check whether the columns were properly created
// The columns of the m_pTable are checked against the column descriptor array <nl>
// returned by ITableDefinition::CreateTable method.
BOOL AreColumnsCreatedOK(
DBCOLUMNDESC *rgOutColumnDesc, // [in] the aray returned by ITableDefinition::CreateTable
DBORDINAL cColumnDesc, // [in] the size of the arrays
DBID *pTableID = NULL, // [in] Table ID of the table that is checked
IUnknown *pIUnknown = NULL // [in] pointer to a rowset interface on the table
);
// @cmember Check whether the property sets asked for rowset was preserved
// all the data should be inside, the only thing that is allowed to be modified <nl>
// is the property status
BOOL IsRowsetPropSetPreserved
(
DBPROPSET *rgInPropertySets, // the array passed to ITableDefinition::CreateTable
DBPROPSET *rgOutPropertysets, // the aray returned by ITableDefinition::CreateTable
ULONG cPropertySets // the size of the arrays
);
// @cmember Check whether the rowset properties were properly created
// The rowset properties of the m_pTable are checked against the property set<nl>
// returned by ITableDefinition::CreateTable method.
BOOL IsRowsetPropSetCreatedOK
(
DBPROPSET *rgOutPropertySets, // the aray returned by ITableDefinition::CreateTable
ULONG cPropertySets, // the size of the arrays
IUnknown *pIUnknown // pointer to rowset interface
);
// @cmember Creates a table with a column of each provider type and returns a rowset
// to the new created table. The rowset is created with the properties required and it
// is tested
BOOL CreateWithRowsetProps
(
ULONG nProperties, // number of the properties to be set
DBPROPID *rgPropID, // array with the propIDs
DBTYPE *rgDBType, // type of property values
LPVOID *rgValue, // values to be set
DBPROPOPTIONS *rgOptions, // options of properties
struct _GUID *pRIID // interface asked on rowset
);
// @cmember Creates a table with a column of each provider type and returns a rowset
// to the new created table. The rowset is created with the property required and it
// is tested
int CreateWithOneRowsetProps
(
DBPROPID PropID, // Property ID
DBTYPE DBType, // type of property value
LPVOID Value, // value to be set
struct _GUID *pRIID // interface asked on rowset
);
public:
HRESULT AddUniqueConstraint(
CTable *pTable,
DBORDINAL ulCol,
DBDEFERRABILITY Deferrability = 0
);
HRESULT AddUniqueConstraint(
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability = 0
);
HRESULT AddPrimaryKeyConstraint(
CTable *pTable,
DBORDINAL ulCol,
DBDEFERRABILITY Deferrability = 0
);
HRESULT AddPrimaryKeyConstraint(
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability = 0
);
HRESULT AddKeyConstraint(
DBCONSTRAINTTYPE ConstraintType,
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability = 0
);
HRESULT AddForeignKeyConstraint(
CTable *pBaseTable,
DBORDINAL cBaseCol,
DBORDINAL *rgBaseCol,
CTable *pReferencedTable,
DBORDINAL cReferencedCol,
DBORDINAL *rgReferencedCol,
DBMATCHTYPE MatchType,
DBUPDELRULE UpdateRule = DBUPDELRULE_NOACTION,
DBUPDELRULE DeleteRule = DBUPDELRULE_NOACTION,
DBDEFERRABILITY Deferrability = 0
);
ITableDefinition *pITableDefinition() {return m_pITableDefinition;}
ITableDefinitionWithConstraints *pITDWC() {return m_pITDWC;}
DBMATCHTYPE SupportedMatchType() {
return m_SupportedMatchType;
}
// @member Add a constraint to a table using ITableDefinitionWithConstraints::AddConstraint and check its creation
HRESULT AddConstraintAndCheck(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
DBID *pTableID, // [in] pointer to the input table ID
DBCONSTRAINTDESC *pConstraintDescs, // [in] new constraint
BOOL fDifferentColTypesInFK = FALSE
);
// @member Drop a constraint to a table using ITableDefinitionWithConstraints::DropConstraint and check its deletion
HRESULT DropConstraintAndCheck(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
DBID *pTableID, // [in] pointer to the input table ID
DBID *pConstraintID // [in] pointer to the DBID of the constraint
);
// @cmember Start a local transaction using the interface pointer passed
HRESULT StartTransaction(ITransactionLocal *pITransactionLocal);
// @cmember Fills in a variant with whatever it needs
BOOL FillVariant(VARIANT *pVariant);
// @cmember Builds a default value for a given column type
BOOL GetDefaultValue(
DBCOLUMNDESC *pColumnDesc, // [in] column for which the default is build
VARIANT *pVariant, // [out] variant that contains the default value
CTable *pTable=NULL // [in] CTable to use
);
// @cmember CompareColumnDesc
// check the new column (first parameter against the result of
BOOL CompareColumnDesc(DBCOLUMNDESC*, DBCOLUMNDESC*);
// @cmember Compare 2 columns got by GetColumnDescOnTable
BOOL AreColEqual(DBCOLUMNDESC*, DBCOLUMNDESC *);
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
virtual unsigned MyThreadProc(ULONG i) {return i;}
//constructor
TCITableDefinition(WCHAR *wstrTestCaseName);
// checks the interfaces on the object, as well as count reference and parent of the rowset
BOOL CheckRowset(IUnknown* pIRowset);
// @cmember GetInfo about the columns in the table
BOOL GetColumnInfo(DBID*, DBORDINAL*, DBCOLUMNINFO**, OLECHAR**);
// @cmember Get an array od Column Descriptors on a Table
BOOL GetColumnDescOnTable(DBID*, DBCOLUMNDESC**, DBORDINAL*);
//destructor
virtual ~TCITableDefinition(){;}
// @cmember Get the number of tables in a data sources, based on IDBSchemaRowset
ULONG GetNoOfTables();
//---------------------------------------------------------------------------
// Insert |
// Inserts 1 row in table using IRowsetChange.
//
// @mfunc Insert
// @rdesc HRESULT indicating success or failure
// @flag S_OK | Function ran without problem
// @flag E_FAIL | No Columns Marked for use or SetNewData failed
//
//---------------------------------------------------------------------------
HRESULT Insert(
DBCOUNTITEM ulRowNumber, // @parm [IN] Row number to insert (0 for next)
IUnknown *pIUnknown, // @parm [IN] Pointer to rowset interface
ULONG cNulls = 0, // @parm [IN] Number of columns to be set to NULL
DBORDINAL *rgNulls = NULL, // @parm [IN] Array of columns to be set to NULL
CTable *pTable = NULL // @parm [IN] Table (DEFAULT NULL - use m_pTable)
);
// creates a table with not nullable column
HRESULT CreateTableWithNoNullableColumns(
CTable *pTable, // @param [IN] pointer to CTable
DBCOUNTITEM ulRowCount, // @parm [IN] # of Rows to insert into table, 1 based
DBORDINAL ulIndex = 0, // @parm [IN] Column Number of index, 1 based (Default=1)
WCHAR *pwszTableName = NULL, // @parm [IN] TableName, if NULL call MakeTableName() (Default=NULL)
EVALUE eValue = PRIMARY, // @parm [IN] Insert PRIMARY or SECONDARY data (Default=PRIMARY)
BOOL fFirstUpdateable = FALSE // @parm [IN] TRUE means first column will be autoinc (Default=FALSE)
);
// @member Create the table using ITableDefinition::CreateTable and check its creation
virtual HRESULT CreateAndCheckTable(
ITableDefinition *pITableDefinition, // [in] pointer to the ITableDefinition interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
);
// @member Create the table using ITableDefinitionWithConstraints::CreateTableWithConstraints and check its creation
HRESULT CreateAndCheckTableWithConstraints(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
ULONG cConstraintDescs, // [in] the number of constraints to be created
DBCONSTRAINTDESC *rgConstraintDescs, // [in/out] array of constraints
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
);
// @cmember Set a property in the property sets of a DBCOLUMNDESC
BOOL SetProperty(
DBPROPSET **prgPropertySets, // [in/out] array of property sets
ULONG *pcPropertySets, // [in/out] number of property sets
DBPROPID propID, // [in] property ID
DBTYPE wType, // [in] value type
LPVOID value, // [in] property value
DBPROPOPTIONS dwOption = DBPROPOPTIONS_OPTIONAL, // [in] prop options
DBID colid = DB_NULLID, // [in] col id
GUID guidPropertySet = DBPROPSET_COLUMN, // [in] the GUID of the propset
ULONG *pcPropSet = NULL, // [out] index of property set
ULONG *pcProp =NULL // [out] index in the rgProperties array
);
};
class CLimitTable {
IDBSchemaRowset *m_pIDBSchemaRowset;
ITableDefinitionWithConstraints *m_pITDWC;
DBCOUNTITEM m_IndexColSize,
m_IndexNullable,
m_IndexLong,
m_IndexFixedLength,
m_IndexDataType,
m_IndexTypeName;
// Selected column specs
DBLENGTH m_cSelectedColSize;
DBTYPE m_dbtSelectedCol;
WCHAR *m_pwszSelectedCol;
HRESULT Init();
HRESULT GetBestType();
HRESULT FindIndexes(IRowset *pIRowset);
HRESULT CreateTable(DBCOUNTITEM cTotalCol, DBID **ppTableID);
HRESULT CreatePrimaryKey(DBID *pTableID, DBCOUNTITEM cTotalCols);
HRESULT CreateUniqueKey(DBID *pTableID, DBCOUNTITEM cTotalCols);
HRESULT CreateForeignKey(DBID *pBaseID, DBID *pRefID, DBCOUNTITEM cTotalCols);
public:
CLimitTable();
~CLimitTable();
HRESULT CheckPrimaryKeyLimit();
HRESULT CheckUniqueKeyLimit();
HRESULT CheckForeignKeyLimit();
HRESULT DropTable(DBID *pTableID);
};
CLimitTable::CLimitTable() {
m_pIDBSchemaRowset = NULL;
m_pITDWC = NULL;
m_IndexColSize = -1;
m_IndexNullable = -1;
m_IndexLong = -1;
m_IndexFixedLength = -1;
m_IndexDataType = -1;
m_IndexTypeName = -1;
m_cSelectedColSize = ULONG_MAX;
m_dbtSelectedCol = -1;
m_pwszSelectedCol = NULL;
}
CLimitTable::~CLimitTable() {
PROVIDER_FREE(m_pwszSelectedCol);
SAFE_RELEASE(m_pITDWC);
SAFE_RELEASE(m_pIDBSchemaRowset);
}
HRESULT CLimitTable::Init() {
TBEGIN
ULONG ulTotalSchemas = 0,
i;
GUID *rgSchemas = NULL;
ULONG *rgRestrictions = NULL;
bool fResult = false;
// init varaibles
m_IndexColSize = -1;
m_IndexNullable = -1;
m_IndexLong = -1;
m_IndexFixedLength = -1;
m_IndexDataType = -1;
m_IndexTypeName = -1;
m_cSelectedColSize = ULONG_MAX;
m_dbtSelectedCol = -1;
PROVIDER_FREE(m_pwszSelectedCol);
SAFE_RELEASE(m_pITDWC);
SAFE_RELEASE(m_pIDBSchemaRowset);
// Verify that IDBSchemaRowset is supported
TESTC_PROVIDER(VerifyInterface(GetModInfo()->GetThisTestModule()->m_pIUnknown2, IID_IDBSchemaRowset,
SESSION_INTERFACE, (IUnknown**) &m_pIDBSchemaRowset));
// Verify that ITableDefinitionWithConstraints is supported
TESTC_PROVIDER(VerifyInterface(GetModInfo()->GetThisTestModule()->m_pIUnknown2, IID_ITableDefinitionWithConstraints,
SESSION_INTERFACE, (IUnknown**) &m_pITDWC));
// Now check if DBSCHEMA_PROVIDER_TYPES is supported
TESTC_(m_pIDBSchemaRowset->GetSchemas(&ulTotalSchemas, &rgSchemas, &rgRestrictions), S_OK);
fResult = false;
for(i = 0; i < ulTotalSchemas; i++)
if (rgSchemas[i] == DBSCHEMA_PROVIDER_TYPES)
fResult = true;
TESTC(fResult);
CLEANUP:
PROVIDER_FREE(rgSchemas);
PROVIDER_FREE(rgRestrictions);
TRETURN
}
HRESULT CLimitTable::FindIndexes(IRowset *pIRowset) {
TBEGIN
IColumnsInfo *pIColInfo = NULL;
DBORDINAL cTotalCols = 0;
DBCOLUMNINFO *rgColInfo = NULL;
OLECHAR *pwszBuffer = NULL;
ULONG i;
TESTC(pIRowset!=NULL);
TESTC_(pIRowset->QueryInterface(IID_IColumnsInfo, (void**) &pIColInfo), S_OK);
TESTC_(pIColInfo->GetColumnInfo(&cTotalCols, &rgColInfo, &pwszBuffer), S_OK);
for(i=0;i<cTotalCols;i++) {
if (!wcscmp(rgColInfo[i].pwszName, L"COLUMN_SIZE"))
m_IndexColSize = i;
else if (!wcscmp(rgColInfo[i].pwszName, L"IS_NULLABLE"))
m_IndexNullable = i;
else if (!wcscmp(rgColInfo[i].pwszName, L"IS_LONG"))
m_IndexLong = i;
else if (!wcscmp(rgColInfo[i].pwszName, L"IS_FIXEDLENGTH"))
m_IndexFixedLength = i;
else if (!wcscmp(rgColInfo[i].pwszName, L"DATA_TYPE"))
m_IndexDataType = i;
else if (!wcscmp(rgColInfo[i].pwszName, L"TYPE_NAME"))
m_IndexTypeName = i;
}
TESTC(m_IndexColSize!=-1 && m_IndexNullable!=-1 && m_IndexLong!=-1 && m_IndexFixedLength!=-1 &&
m_IndexDataType!=-1 && m_IndexTypeName!=-1);
CLEANUP:
PROVIDER_FREE(pwszBuffer);
PROVIDER_FREE(rgColInfo);
SAFE_RELEASE(pIColInfo);
TRETURN
}
HRESULT CLimitTable::GetBestType() {
TBEGIN
IRowset *pIRowset = NULL;
IAccessor *pIAccessor = NULL;
HACCESSOR hAccessor = NULL;
DBBINDING *rgBindings = NULL;
DBCOUNTITEM cBindings = 0,
cRowSize = 0;
HROW *phRows = NULL;
DBCOUNTITEM cRowsObtained = 0;
char *pszRowData = NULL;
bool fResult = false,
IsSQLServer7 = false;
WCHAR *pwszVer = NULL;
CLSID clsidSQL;
TESTC(m_pIDBSchemaRowset && m_pITDWC);
// Hack for SQL Server 7.0 which doesnt allow keys on BIT data type but provides
// no way to determine this behavior.
TESTC_(CLSIDFromProgID(L"SQLOLEDB", &clsidSQL), S_OK);
if (PROVIDER_CLSID == clsidSQL) {
if (::SupportedProperty(DBPROP_DBMSVER, DBPROPSET_DATASOURCEINFO,
GetModInfo()->GetThisTestModule()->m_pIUnknown)) {
TESTC(::GetProperty(DBPROP_DBMSVER, DBPROPSET_DATASOURCEINFO,
GetModInfo()->GetThisTestModule()->m_pIUnknown,
&pwszVer));
if (wcscmp(pwszVer, L"08.00.0000")<0)
IsSQLServer7 = true;
}
}
// Get provider types rowset
TESTC_(m_pIDBSchemaRowset->GetRowset(NULL, DBSCHEMA_PROVIDER_TYPES, 0, NULL,
IID_IRowset, 0, NULL, (IUnknown**) &pIRowset), S_OK);
// find indexes to different columns
TESTC(FindIndexes(pIRowset));
// get accessor
TESTC(VerifyInterface(pIRowset, IID_IAccessor, ROWSET_INTERFACE, (IUnknown**)&pIAccessor));
// Create accessor
TESTC_(GetAccessorAndBindings(pIRowset, DBACCESSOR_ROWDATA, &hAccessor,
&rgBindings, &cBindings, &cRowSize, DBPART_VALUE | DBPART_STATUS | DBPART_LENGTH,
ALL_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL, NULL,
NULL, DBTYPE_EMPTY, 0, NULL), S_OK);
// Now get data and find best matching row
pszRowData = (char*) PROVIDER_ALLOC(cRowSize);
fResult = false;
while(pIRowset->GetNextRows(DB_NULL_HCHAPTER, 0, 1, &cRowsObtained, &phRows)==S_OK) {
pIRowset->GetData(phRows[0], hAccessor, pszRowData);
if (*(VARIANT_BOOL*)&pszRowData[rgBindings[m_IndexNullable].obValue] == VARIANT_TRUE &&
*(VARIANT_BOOL*)&pszRowData[rgBindings[m_IndexLong].obValue] == VARIANT_FALSE &&
*(VARIANT_BOOL*)&pszRowData[rgBindings[m_IndexFixedLength].obValue] == VARIANT_TRUE &&
!(IsSQLServer7 && !wcscmp((WCHAR*)&pszRowData[rgBindings[m_IndexTypeName].obValue], L"bit"))
) {
if (*(DWORD*)&pszRowData[rgBindings[m_IndexColSize].obValue] < m_cSelectedColSize) {
m_cSelectedColSize = *(DWORD*)&pszRowData[rgBindings[m_IndexColSize].obValue];
m_dbtSelectedCol = *(WORD*) &pszRowData[rgBindings[m_IndexDataType].obValue];
PROVIDER_FREE(m_pwszSelectedCol);
m_pwszSelectedCol = wcsDuplicate((WCHAR*) &pszRowData[rgBindings[m_IndexTypeName].obValue]);
fResult = true;
}
}
TESTC_(pIRowset->ReleaseRows(1, phRows, NULL, NULL, NULL), S_OK)
PROVIDER_FREE(phRows);
cRowsObtained = 0;
}
TESTC(fResult);
odtLog << "Using '" << m_pwszSelectedCol << "' data type to find maximum limit\n";
CLEANUP:
PROVIDER_FREE(rgBindings);
PROVIDER_FREE(pszRowData);
PROVIDER_FREE(pwszVer);
if (hAccessor && pIAccessor)
pIAccessor->ReleaseAccessor(hAccessor, NULL);
SAFE_RELEASE(pIAccessor);
SAFE_RELEASE(pIRowset);
TRETURN
}
HRESULT CLimitTable::CreateTable(DBCOUNTITEM cTotalCol, DBID **ppTableID) {
TBEGIN
DBCOLUMNDESC *rgColDesc = NULL;
DBCOUNTITEM i;
WCHAR *pwszColName = NULL;
IRowset *pIRowset = NULL;
DBID *pid = NULL;
DBPROPSET PropSet;
DBPROP Prop;
rgColDesc = (DBCOLUMNDESC*) PROVIDER_ALLOC(cTotalCol * sizeof(DBCOLUMNDESC));
pwszColName = (WCHAR*) PROVIDER_ALLOC(1024);
Prop.dwPropertyID = DBPROP_COL_NULLABLE;
Prop.dwOptions = DBPROPOPTIONS_REQUIRED;
Prop.dwStatus = DBPROPSTATUS_OK;
Prop.colid = DB_NULLID;
VariantInit(&Prop.vValue);
V_VT(&Prop.vValue) = VT_BOOL;
V_BOOL(&Prop.vValue) = VARIANT_FALSE;
PropSet.guidPropertySet = DBPROPSET_COLUMN;
PropSet.cProperties = 1;
PropSet.rgProperties = &Prop;
// Create Column Description structure
for (i=0; i<cTotalCol; i++) {
swprintf(pwszColName, L"Col%d", i);
rgColDesc[i].pwszTypeName = m_pwszSelectedCol;
rgColDesc[i].pTypeInfo = NULL;
rgColDesc[i].rgPropertySets = &PropSet; //NULL;
rgColDesc[i].pclsid = NULL;
rgColDesc[i].cPropertySets = 1; //0;
rgColDesc[i].ulColumnSize = m_cSelectedColSize;
rgColDesc[i].dbcid.eKind = DBKIND_NAME;
rgColDesc[i].dbcid.uName.pwszName = wcsDuplicate(pwszColName);
rgColDesc[i].bPrecision = 0;
rgColDesc[i].bScale = 0;
}
// Now create table
TESTC_(m_pITDWC->CreateTable(NULL, NULL, cTotalCol,
rgColDesc, IID_IRowset, 0, NULL,
&pid, (IUnknown**) &pIRowset), S_OK);
*ppTableID = pid;
for(i=0;i < cTotalCol; i++)
PROVIDER_FREE(rgColDesc[i].dbcid.uName.pwszName);
CLEANUP:
PROVIDER_FREE(pwszColName);
PROVIDER_FREE(rgColDesc);
SAFE_RELEASE(pIRowset);
TRETURN
}
HRESULT CLimitTable::CreatePrimaryKey(DBID *pTableID, DBCOUNTITEM cTotalCols) {
DBID *pPKDBID = NULL;
DBCOUNTITEM i;
WCHAR *pwszColName = NULL;
HRESULT hr = E_FAIL;
DBCONSTRAINTDESC Cons;
DBID ConsID;
ASSERT(pTableID && cTotalCols > 0);
pwszColName = (WCHAR*) PROVIDER_ALLOC(1024);
// Build PK columns list
pPKDBID = (DBID*) PROVIDER_ALLOC(sizeof(DBID) * cTotalCols);
for(i=0; i<cTotalCols; i++) {
swprintf(pwszColName, L"Col%d", i);
pPKDBID[i].eKind = DBKIND_NAME;
pPKDBID[i].uName.pwszName = wcsDuplicate(pwszColName);
}
// Build constraint DBID
ConsID.eKind = DBKIND_NAME;
ConsID.uName.pwszName = L"PKConstraint";
// Build constraint structure
Cons.pConstraintID = &ConsID;
Cons.ConstraintType = DBCONSTRAINTTYPE_PRIMARYKEY;
Cons.cColumns = cTotalCols;
Cons.rgColumnList = pPKDBID;
Cons.pReferencedTableID = NULL;
Cons.cForeignKeyColumns = 0;
Cons.rgForeignKeyColumnList = NULL;
Cons.pwszConstraintText = NULL;
Cons.cReserved = 0;
Cons.rgReserved = NULL;
Cons.Deferrability = 0;
hr = m_pITDWC->AddConstraint(pTableID, &Cons);
for(i=0; i<cTotalCols; i++)
PROVIDER_FREE(pPKDBID[i].uName.pwszName);
PROVIDER_FREE(pPKDBID);
PROVIDER_FREE(pwszColName);
return hr;
}
HRESULT CLimitTable::CreateUniqueKey(DBID *pTableID, DBCOUNTITEM cTotalCols) {
DBID *pPKDBID = NULL;
DBCOUNTITEM i;
WCHAR *pwszColName = NULL;
HRESULT hr = E_FAIL;
DBCONSTRAINTDESC Cons;
DBID ConsID;
ASSERT(pTableID && cTotalCols > 0);
pwszColName = (WCHAR*) PROVIDER_ALLOC(1024);
// Build PK columns list
pPKDBID = (DBID*) PROVIDER_ALLOC(sizeof(DBID) * cTotalCols);
for(i=0; i<cTotalCols; i++) {
swprintf(pwszColName, L"Col%d", i);
pPKDBID[i].eKind = DBKIND_NAME;
pPKDBID[i].uName.pwszName = wcsDuplicate(pwszColName);
}
// Build constraint DBID
ConsID.eKind = DBKIND_NAME;
ConsID.uName.pwszName = L"UniqueConstraint";
// Build constraint structure
Cons.pConstraintID = &ConsID;
Cons.ConstraintType = DBCONSTRAINTTYPE_UNIQUE;
Cons.cColumns = cTotalCols;
Cons.rgColumnList = pPKDBID;
Cons.pReferencedTableID = NULL;
Cons.cForeignKeyColumns = 0;
Cons.rgForeignKeyColumnList = NULL;
Cons.pwszConstraintText = NULL;
Cons.cReserved = 0;
Cons.rgReserved = NULL;
Cons.Deferrability = 0;
hr = m_pITDWC->AddConstraint(pTableID, &Cons);
for(i=0; i<cTotalCols; i++)
PROVIDER_FREE(pPKDBID[i].uName.pwszName);
PROVIDER_FREE(pPKDBID);
PROVIDER_FREE(pwszColName);
return hr;
}
HRESULT CLimitTable::CreateForeignKey(DBID *pBaseID, DBID *pRefID, DBCOUNTITEM cTotalCols) {
DBID *pPKDBID = NULL,
*pFKDBID = NULL;
DBCOUNTITEM i;
WCHAR *pwszColName = NULL;
HRESULT hr = E_FAIL;
DBCONSTRAINTDESC Cons;
DBID ConsID;
ASSERT(pBaseID && pRefID && cTotalCols > 0);
pwszColName = (WCHAR*) PROVIDER_ALLOC(1024);
// Build PK columns list
pPKDBID = (DBID*) PROVIDER_ALLOC(sizeof(DBID) * cTotalCols);
for(i=0; i<cTotalCols; i++) {
swprintf(pwszColName, L"Col%d", i);
pPKDBID[i].eKind = DBKIND_NAME;
pPKDBID[i].uName.pwszName = wcsDuplicate(pwszColName);
}
// Build FK columns list
pFKDBID = (DBID*) PROVIDER_ALLOC(sizeof(DBID) * cTotalCols);
for(i=0; i<cTotalCols; i++) {
swprintf(pwszColName, L"Col%d", i);
pFKDBID[i].eKind = DBKIND_NAME;
pFKDBID[i].uName.pwszName = wcsDuplicate(pwszColName);
}
// Build constraint DBID
ConsID.eKind = DBKIND_NAME;
ConsID.uName.pwszName = L"FKConstraint";
// Build constraint structure
Cons.pConstraintID = &ConsID;
Cons.ConstraintType = DBCONSTRAINTTYPE_FOREIGNKEY;
Cons.cColumns = cTotalCols;
Cons.rgColumnList = pPKDBID;
Cons.pReferencedTableID = pRefID;
Cons.cForeignKeyColumns = cTotalCols;
Cons.rgForeignKeyColumnList = pFKDBID;
Cons.pwszConstraintText = NULL;
Cons.cReserved = 0;
Cons.rgReserved = NULL;
Cons.Deferrability = 0;
Cons.UpdateRule = DBUPDELRULE_NOACTION;
Cons.DeleteRule = DBUPDELRULE_NOACTION;
Cons.MatchType = DBMATCHTYPE_NONE;
TESTC_(hr = m_pITDWC->AddConstraint(pBaseID, &Cons), S_OK);
for(i=0; i<cTotalCols; i++) {
PROVIDER_FREE(pPKDBID[i].uName.pwszName);
PROVIDER_FREE(pFKDBID[i].uName.pwszName);
}
PROVIDER_FREE(pPKDBID);
PROVIDER_FREE(pFKDBID);
PROVIDER_FREE(pwszColName);
CLEANUP:
return hr;
}
HRESULT CLimitTable::CheckPrimaryKeyLimit() {
TBEGIN
DBID *pTableID = NULL;
DBCOUNTITEM i = 0;
HRESULT hr = S_OK;
// Initialize everything
TESTC(Init());
// Get provider types to be used in testing
TESTC(GetBestType());
// find the limit
for(i = 1; i <= 256; i++) {
TESTC(CreateTable(i, &pTableID));
hr = CreatePrimaryKey(pTableID, i);
TESTC(DropTable(pTableID));
if (FAILED(hr)) {
hr = S_OK;
break;
}
}
i--;
odtLog << "Maximum columns in Primary Key allowed: " << i << "\n";
TESTC(i != 0);
CLEANUP:
return hr;
}
HRESULT CLimitTable::CheckUniqueKeyLimit() {
TBEGIN
DBID *pTableID = NULL;
DBCOUNTITEM i = 0;
HRESULT hr = S_OK;
// Initialize everything
TESTC(Init());
// Get provider types to be used in testing
TESTC(GetBestType());
// find the limit
for(i = 1; i <= 256; i++) {
TESTC(CreateTable(i, &pTableID));
hr = CreateUniqueKey(pTableID, i);
TESTC(DropTable(pTableID));
if (FAILED(hr)) {
hr = S_OK;
break;
}
}
i--;
odtLog << "Maximum columns in Unique Key allowed: " << i << "\n";
TESTC(i != 0);
CLEANUP:
return hr;
}
HRESULT CLimitTable::CheckForeignKeyLimit() {
TBEGIN
DBID *pBaseID = NULL,
*pRefID = NULL;
DBCOUNTITEM i = 0;
HRESULT hr = S_OK;
// Initialize everything
TESTC(Init());
// Get provider types to be used in testing
TESTC(GetBestType());
// find the limit
for(i = 1; i <= 256; i++) {
TESTC(CreateTable(i, &pBaseID));
TESTC(CreateTable(i, &pRefID));
hr = CreatePrimaryKey(pBaseID, i);
if (SUCCEEDED(hr)) {
hr = CreateUniqueKey(pRefID, i);
if (SUCCEEDED(hr)) {
hr = CreateForeignKey(pBaseID, pRefID, i);
}
}
TESTC(DropTable(pBaseID));
TESTC(DropTable(pRefID));
PROVIDER_FREE(pBaseID);
PROVIDER_FREE(pRefID);
if (FAILED(hr)) {
hr = S_OK;
break;
}
}
i--;
odtLog << "Maximum columns in Foreign Key allowed: " << i << "\n";
TESTC(i != 0);
CLEANUP:
return hr;
}
HRESULT CLimitTable::DropTable(DBID *pTableID)
{
TBEGIN
TESTC(m_pITDWC != NULL);
TESTC_(m_pITDWC->DropTable(pTableID), S_OK);
CLEANUP:
TRETURN
}
// {{ TCW_TEST_CASE_MAP(TCAddColumn)
//--------------------------------------------------------------------
// @class Testcase for ITableDefinition::AddColumn
//
class TCAddColumn : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddColumn,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Table doesn't exist => DB_E_NOTABLE
int Variation_1();
// @cmember The table is in use => DB_E_TABLEINUSE
int Variation_2();
// @cmember *pTableID = DB_NULLID => DB_E_NOTABLE
int Variation_3();
// @cmember pTableID = NULL => E_INVALIDARG
int Variation_4();
// @cmember Maximum length for table name => S_OK
int Variation_5();
// @cmember the table name is 1 char too long => DB_E_NOTABLE
int Variation_6();
// @cmember invalid table name => DB_E_NOTABLE
int Variation_7();
// @cmember pColumnDesc->dbcid = DB_NULLID
int Variation_8();
// @cmember Column name pointer is NULL => DB_E_BADCOLUMNID
int Variation_9();
// @cmember column name is an empty string => DB_E_BADCOLUMNID
int Variation_10();
// @cmember Maximum length of column name => S_OK
int Variation_11();
// @cmember 1-char-too-long column name => DB_E_BADCOLUMNID
int Variation_12();
// @cmember Add a column for each provider type, maximum column size => S_OK
int Variation_13();
// @cmember Add a column for each known type; ulColumnsize == 0 => S_OK
int Variation_14();
// @cmember Add a column for each provider type (table is populated) => S_OK
int Variation_15();
// @cmember Precision testing
int Variation_16();
// @cmember Scale testing
int Variation_17();
// @cmember Invalid value for the property of a column => DB_E_ERRORSOCCURRED
int Variation_18();
// @cmember Non-column property => DBPROPSTATUS_NOTSUPPORTED
int Variation_19();
// @cmember Inexistent property => DBPROPSTATUS_NOTSUPPORTED
int Variation_20();
// @cmember Bad option => DBPROPSTATUS_BADOPTION
int Variation_21();
// @cmember Conflicting property => DBPROPSTATUS_CONFLICTING
int Variation_22();
// @cmember Bad column ID for a property => ignored
int Variation_23();
// @cmember Bad column type (wType in DBCOLUMNDESC)
int Variation_24();
// @cmember Invalid provider type name for a column => DB_E_BADTYPE
int Variation_25();
// @cmember NULL ppColumnDesc => S_OK
int Variation_26();
// @cmember Autoincrementable column - DBPROP_COL_AUTOINCREMENT
int Variation_27();
// @cmember DBPROP_COL_DEFAULT
int Variation_28();
// @cmember DBPROP_COL_DESCRIPTION
int Variation_29();
// @cmember DBPROP_COL_FIXEDLENGTH
int Variation_30();
// @cmember DBPROP_COL_NULLABLE
int Variation_31();
// @cmember DBPROP_PRIMARYKEY
int Variation_32();
// @cmember DBPROP_COL_UNIQUE
int Variation_33();
// @cmember Duplicate an existing column => DB_E_DUPLCATECOLUMNID
int Variation_34();
// @cmember Abort retaining
int Variation_35();
// @cmember Abort without retaining
int Variation_36();
// @cmember Commit with retain
int Variation_37();
// @cmember Commit without retain
int Variation_38();
// @cmember Add a column for each provider type in an empty table => S_OK
int Variation_39();
// @cmember Add a column to a table created with a SQL command => S_OK
int Variation_40();
// @cmember Drop all the column of a table (via SQL stmt) and then try to add a column => S_OK
int Variation_41();
// @cmember Non NULL pTypeInfo in DBCOLUMNDESC => DB_E_BADTYPE
int Variation_42();
// @cmember Missmatch between wType and pwszTypeName => DB_E_BADTYPE
int Variation_43();
// @cmember Add a not nullable column and try to insert a null value for it
int Variation_44();
// @cmember Add a column on a view
int Variation_45();
// @cmember eKind != DBKIND_NAME for a column
int Variation_46();
// @cmember threads with different column
int Variation_47();
// @cmember threads on the same column
int Variation_48();
// @cmember add columns of alll known wType => S_OK
int Variation_49();
// @cmember Fully Qualified table name
int Variation_50();
// @cmember Quoted Table Name
int Variation_51();
// @cmember pColumnDesc == NULL => E_INVALIDARG
int Variation_52();
// @cmember cPropertySets != 0 and rgPropertySets == NULL in pColumnDesc => E_INVALIDARG
int Variation_53();
// @cmember cPropertySets == 0 and rgPropertySets != NULL in pColumnDesc => S_OK
int Variation_54();
// @cmember cProperties == 0 and rgProperties != NULL in pColumnDesc's propset => S_OK
int Variation_55();
// @cmember cProperties != 0 and rgProperties == NULL in pColumnDesc's propset => E_INVALIDARG
int Variation_56();
// @cmember pclsid not null
int Variation_57();
// @cmember NULL pwszTypeName => S_OK
int Variation_58();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
};
// {{ TCW_TESTCASE(TCAddColumn)
#define THE_CLASS TCAddColumn
BEG_TEST_CASE(TCAddColumn, TCITableDefinition, L"Testcase for ITableDefinition::AddColumn")
TEST_VARIATION(1, L"Table doesn't exist => DB_E_NOTABLE")
TEST_VARIATION(2, L"The table is in use => DB_E_TABLEINUSE")
TEST_VARIATION(3, L"*pTableID = DB_NULLID => DB_E_NOTABLE")
TEST_VARIATION(4, L"pTableID = NULL => E_INVALIDARG")
TEST_VARIATION(5, L"Maximum length for table name => S_OK")
TEST_VARIATION(6, L"the table name is 1 char too long => DB_E_NOTABLE")
TEST_VARIATION(7, L"invalid table name => DB_E_NOTABLE")
TEST_VARIATION(8, L"pColumnDesc->dbcid = DB_NULLID")
TEST_VARIATION(9, L"Column name pointer is NULL => DB_E_BADCOLUMNID")
TEST_VARIATION(10, L"column name is an empty string => DB_E_BADCOLUMNID")
TEST_VARIATION(11, L"Maximum length of column name => S_OK")
TEST_VARIATION(12, L"1-char-too-long column name => DB_E_BADCOLUMNID")
TEST_VARIATION(13, L"Add a column for each provider type, maximum column size => S_OK")
TEST_VARIATION(14, L"Add a column for each known type; ulColumnsize == 0 => S_OK")
TEST_VARIATION(15, L"Add a column for each provider type (table is populated) => S_OK")
TEST_VARIATION(16, L"Precision testing")
TEST_VARIATION(17, L"Scale testing")
TEST_VARIATION(18, L"Invalid value for the property of a column => DB_E_ERRORSOCCURRED")
TEST_VARIATION(19, L"Non-column property => DBPROPSTATUS_NOTSUPPORTED")
TEST_VARIATION(20, L"Inexistent property => DBPROPSTATUS_NOTSUPPORTED")
TEST_VARIATION(21, L"Bad option => DBPROPSTATUS_BADOPTION")
TEST_VARIATION(22, L"Conflicting property => DBPROPSTATUS_CONFLICTING")
TEST_VARIATION(23, L"Bad column ID for a property => ignored")
TEST_VARIATION(24, L"Bad column type (wType in DBCOLUMNDESC)")
TEST_VARIATION(25, L"Invalid provider type name for a column => DB_E_BADTYPE")
TEST_VARIATION(26, L"NULL ppColumnDesc => S_OK")
TEST_VARIATION(27, L"Autoincrementable column - DBPROP_COL_AUTOINCREMENT")
TEST_VARIATION(28, L"DBPROP_COL_DEFAULT")
TEST_VARIATION(29, L"DBPROP_COL_DESCRIPTION")
TEST_VARIATION(30, L"DBPROP_COL_FIXEDLENGTH")
TEST_VARIATION(31, L"DBPROP_COL_NULLABLE")
TEST_VARIATION(32, L"DBPROP_PRIMARYKEY")
TEST_VARIATION(33, L"DBPROP_COL_UNIQUE")
TEST_VARIATION(34, L"Duplicate an existing column => DB_E_DUPLCATECOLUMNID")
TEST_VARIATION(35, L"Abort retaining")
TEST_VARIATION(36, L"Abort without retaining")
TEST_VARIATION(37, L"Commit with retain")
TEST_VARIATION(38, L"Commit without retain")
TEST_VARIATION(39, L"Add a column for each provider type in an empty table => S_OK")
TEST_VARIATION(40, L"Add a column to a table created with a SQL command => S_OK")
TEST_VARIATION(41, L"Drop all the column of a table (via SQL stmt) and then try to add a column => S_OK")
TEST_VARIATION(42, L"Non NULL pTypeInfo in DBCOLUMNDESC => DB_E_BADTYPE")
TEST_VARIATION(43, L"Missmatch between wType and pwszTypeName => DB_E_BADTYPE")
TEST_VARIATION(44, L"Add a not nullable column and try to insert a null value for it")
TEST_VARIATION(45, L"Add a column on a view")
TEST_VARIATION(46, L"eKind != DBKIND_NAME for a column")
TEST_VARIATION(47, L"threads with different column")
TEST_VARIATION(48, L"threads on the same column")
TEST_VARIATION(49, L"add columns of alll known wType => S_OK")
TEST_VARIATION(50, L"Fully Qualified table name")
TEST_VARIATION(51, L"Quoted Table Name")
TEST_VARIATION(52, L"pColumnDesc == NULL => E_INVALIDARG")
TEST_VARIATION(53, L"cPropertySets != 0 and rgPropertySets == NULL in pColumnDesc => E_INVALIDARG")
TEST_VARIATION(54, L"cPropertySets == 0 and rgPropertySets != NULL in pColumnDesc => S_OK")
TEST_VARIATION(55, L"cProperties == 0 and rgProperties != NULL in pColumnDesc's propset => S_OK")
TEST_VARIATION(56, L"cProperties != 0 and rgProperties == NULL in pColumnDesc's propset => E_INVALIDARG")
TEST_VARIATION(57, L"pclsid not null")
TEST_VARIATION(58, L"NULL pwszTypeName => S_OK")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCDropColumn)
//--------------------------------------------------------------------
// @class Test case for dropping columns
//
class TCDropColumn : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCDropColumn,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pTableID is NULL => E_INVALIDARG
int Variation_1();
// @cmember pColumnID in NULL => E_INVALIDARG
int Variation_2();
// @cmember *pTableID is DB_NULLID => DB_E_NOTABLE
int Variation_3();
// @cmember *pColumnID is DB_NULLID => DB_E_NOCOLUMN
int Variation_4();
// @cmember Maximum length table name => S_OK
int Variation_5();
// @cmember 1-char-too long table name => DB_E_NOTABLE
int Variation_6();
// @cmember *pTableID contains a NULL table name => DB_E_NOTABLE
int Variation_7();
// @cmember *pTableID contains an invalid name => DB_E_NOTABLE
int Variation_8();
// @cmember Maximum length for a column name => S_OK
int Variation_9();
// @cmember 1-char-too-long column name => DB_E_NOCOLUMN
int Variation_10();
// @cmember *pColumnID contains a NULL column name pointer => E_INVALIDARG
int Variation_11();
// @cmember *pColumnID contains an invalid column name => E_INVALID ARG
int Variation_12();
// @cmember Drop all the columns of a table => S_OK
int Variation_13();
// @cmember Try to delete an inexistent column => DB_E_NOCOLUMN
int Variation_14();
// @cmember Table in use => DB_E_TABLEINUSE
int Variation_15();
// @cmember Valid name of an inexistent table => DB_E_NOTABLE
int Variation_16();
// @cmember Abort with retaining
int Variation_17();
// @cmember Abort without retaining
int Variation_18();
// @cmember Commit with retaining
int Variation_19();
// @cmember Commit without retaining
int Variation_20();
// @cmember threads on different columns
int Variation_21();
// @cmember threads on the same column
int Variation_22();
// @cmember Drop a column twice => DB_E_NOCOLUMN
int Variation_23();
// @cmember 2 TableDefinition interfaces on the same table, try to drop 2 different columns => S_OK
int Variation_24();
// @cmember Drop as many column as possible from a table created with a SQL statement
int Variation_25();
// @cmember Drop a column from a 2 column table
int Variation_26();
// @cmember drop a column from a 1 column table
int Variation_27();
// @cmember drop a column from a non empty table => S_OK
int Variation_28();
// @cmember drop a column from an empty table
int Variation_29();
// @cmember drop a nullable, an autoincrementable and a default value column
int Variation_30();
// @cmember try to drop a column from a view
int Variation_31();
// @cmember drop a column added with an alter table command => S_OK
int Variation_32();
// @cmember try to drop columns using different DBKIND pattern
int Variation_33();
// @cmember Fully Qualified Table Name
int Variation_34();
// @cmember Quoted Table Name
int Variation_35();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
};
// {{ TCW_TESTCASE(TCDropColumn)
#define THE_CLASS TCDropColumn
BEG_TEST_CASE(TCDropColumn, TCITableDefinition, L"Test case for dropping columns")
TEST_VARIATION(1, L"pTableID is NULL => E_INVALIDARG")
TEST_VARIATION(2, L"pColumnID in NULL => E_INVALIDARG")
TEST_VARIATION(3, L"*pTableID is DB_NULLID => DB_E_NOTABLE")
TEST_VARIATION(4, L"*pColumnID is DB_NULLID => DB_E_NOCOLUMN")
TEST_VARIATION(5, L"Maximum length table name => S_OK")
TEST_VARIATION(6, L"1-char-too long table name => DB_E_NOTABLE")
TEST_VARIATION(7, L"*pTableID contains a NULL table name => DB_E_NOTABLE")
TEST_VARIATION(8, L"*pTableID contains an invalid name => DB_E_NOTABLE")
TEST_VARIATION(9, L"Maximum length for a column name => S_OK")
TEST_VARIATION(10, L"1-char-too-long column name => DB_E_NOCOLUMN")
TEST_VARIATION(11, L"*pColumnID contains a NULL column name pointer => E_INVALIDARG")
TEST_VARIATION(12, L"*pColumnID contains an invalid column name => E_INVALID ARG")
TEST_VARIATION(13, L"Drop all the columns of a table => S_OK")
TEST_VARIATION(14, L"Try to delete an inexistent column => DB_E_NOCOLUMN")
TEST_VARIATION(15, L"Table in use => DB_E_TABLEINUSE")
TEST_VARIATION(16, L"Valid name of an inexistent table => DB_E_NOTABLE")
TEST_VARIATION(17, L"Abort with retaining")
TEST_VARIATION(18, L"Abort without retaining")
TEST_VARIATION(19, L"Commit with retaining")
TEST_VARIATION(20, L"Commit without retaining")
TEST_VARIATION(21, L"threads on different columns")
TEST_VARIATION(22, L"threads on the same column")
TEST_VARIATION(23, L"Drop a column twice => DB_E_NOCOLUMN")
TEST_VARIATION(24, L"2 TableDefinition interfaces on the same table, try to drop 2 different columns => S_OK")
TEST_VARIATION(25, L"Drop as many column as possible from a table created with a SQL statement")
TEST_VARIATION(26, L"Drop a column from a 2 column table")
TEST_VARIATION(27, L"drop a column from a 1 column table")
TEST_VARIATION(28, L"drop a column from a non empty table => S_OK")
TEST_VARIATION(29, L"drop a column from an empty table")
TEST_VARIATION(30, L"drop a nullable, an autoincrementable and a default value column")
TEST_VARIATION(31, L"try to drop a column from a view")
TEST_VARIATION(32, L"drop a column added with an alter table command => S_OK")
TEST_VARIATION(33, L"try to drop columns using different DBKIND pattern")
TEST_VARIATION(34, L"Fully Qualified Table Name")
TEST_VARIATION(35, L"Quoted Table Name")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCDropTable)
//--------------------------------------------------------------------
// @class Test Case fo dropping a table
//
class TCDropTable : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCDropTable,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pTableID is NULL => E_INVALIDARG
int Variation_1();
// @cmember *pTableID is DB_NULLID => DB_E_NOTABLE
int Variation_2();
// @cmember Maximum length for table name => S_OK
int Variation_3();
// @cmember 1-char-too-long table name => DB_E_NOTABLE
int Variation_4();
// @cmember The pointer to the table name is NULL => DB_E_NOTABLE
int Variation_5();
// @cmember Table name is empty => DB_E_NOTABLE
int Variation_6();
// @cmember Invalid table name => DB_E_NOTABLE
int Variation_7();
// @cmember A rowset is opened on table => DB_E_TABLEINUSE
int Variation_8();
// @cmember Table in use => DB_E_TABLEINUSE
int Variation_9();
// @cmember Inexistent table => DB_E_NOTABLE
int Variation_10();
// @cmember Abort with retaining
int Variation_11();
// @cmember Abort without retaining
int Variation_12();
// @cmember Commit with retaining
int Variation_13();
// @cmember Commit without retaining
int Variation_14();
// @cmember Drop a table created with an SQL command => S_OK
int Variation_15();
// @cmember Drop a table created with ITableDefinition, no rowset created => S_OK
int Variation_16();
// @cmember Drop a table created with ITableDefinition, rowset released => S_OK
int Variation_17();
// @cmember ITableDefinition::CreateTable, insert 10 rows, release rowset, drop the table => S_OK
int Variation_18();
// @cmember For each provider type, create a table with a single column and then drop it => S_OK
int Variation_19();
// @cmember Drop a table twice => DB_E_NOTABLE
int Variation_20();
// @cmember threads on different tables
int Variation_21();
// @cmember threads on same table
int Variation_22();
// @cmember Fully Qualified Table Name
int Variation_23();
// @cmember Quoted Table Name
int Variation_24();
// @cmember Different DBKINDs for pTableID
int Variation_25();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
};
// {{ TCW_TESTCASE(TCDropTable)
#define THE_CLASS TCDropTable
BEG_TEST_CASE(TCDropTable, TCITableDefinition, L"Test Case fo dropping a table")
TEST_VARIATION(1, L"pTableID is NULL => E_INVALIDARG")
TEST_VARIATION(2, L"*pTableID is DB_NULLID => DB_E_NOTABLE")
TEST_VARIATION(3, L"Maximum length for table name => S_OK")
TEST_VARIATION(4, L"1-char-too-long table name => DB_E_NOTABLE")
TEST_VARIATION(5, L"The pointer to the table name is NULL => DB_E_NOTABLE")
TEST_VARIATION(6, L"Table name is empty => DB_E_NOTABLE")
TEST_VARIATION(7, L"Invalid table name => DB_E_NOTABLE")
TEST_VARIATION(8, L"A rowset is opened on table => DB_E_TABLEINUSE")
TEST_VARIATION(9, L"Table in use => DB_E_TABLEINUSE")
TEST_VARIATION(10, L"Inexistent table => DB_E_NOTABLE")
TEST_VARIATION(11, L"Abort with retaining")
TEST_VARIATION(12, L"Abort without retaining")
TEST_VARIATION(13, L"Commit with retaining")
TEST_VARIATION(14, L"Commit without retaining")
TEST_VARIATION(15, L"Drop a table created with an SQL command => S_OK")
TEST_VARIATION(16, L"Drop a table created with ITableDefinition, no rowset created => S_OK")
TEST_VARIATION(17, L"Drop a table created with ITableDefinition, rowset released => S_OK")
TEST_VARIATION(18, L"ITableDefinition::CreateTable, insert 10 rows, release rowset, drop the table => S_OK")
TEST_VARIATION(19, L"For each provider type, create a table with a single column and then drop it => S_OK")
TEST_VARIATION(20, L"Drop a table twice => DB_E_NOTABLE")
TEST_VARIATION(21, L"threads on different tables")
TEST_VARIATION(22, L"threads on same table")
TEST_VARIATION(23, L"Fully Qualified Table Name")
TEST_VARIATION(24, L"Quoted Table Name")
TEST_VARIATION(25, L"Different DBKINDs for pTableID")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCCreateTable)
//--------------------------------------------------------------------
// @class TestCase for table creation
//
class TCCreateTable : public TCITableDefinition {
public:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCreateTable,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Session interfaces
int Variation_1();
// @cmember pTableID is NULL => S_OK
int Variation_2();
// @cmember ppTableID is a NULL pointer => S_OK
int Variation_3();
// @cmember pTableID and ppTableID both NULL => E_INVALIDARG
int Variation_4();
// @cmember *pTableID == DB_NULLID => DB_E_BADTABLEID
int Variation_5();
// @cmember cColumnDesc == 0 => E_INVALIDARG or S_OK
int Variation_6();
// @cmember rgColumnDesc == NULL => E_INVALIDARG
int Variation_7();
// @cmember cPropertySets != 0 and rgPropertySets == NULL => E_INVALIDARG
int Variation_8();
// @cmember cPropertySets is 0 and rgPropertySets != NULL => S_OK
int Variation_9();
// @cmember for a property sets, cProperties != 0 and rgProperties == NULL => E_INVALIDARG
int Variation_10();
// @cmember cProperties == 0 on a property set => S_OK
int Variation_11();
// @cmember for a column, rgPropertySets is NULL though cPropertySets != 0 => E_INVALIDARG
int Variation_12();
// @cmember dbcid in an element of rgColumnDesc is DB_NULLID => DB_E_BADCOLUMNID
int Variation_13();
// @cmember dbcid in an element of rgColumnDesc is NULL => DB_E_BADCOLUMNID
int Variation_14();
// @cmember not null pclsid in a DBCOLUMNDESC element
int Variation_15();
// @cmember empty column name => DB_E_BADCOLUMNID
int Variation_16();
// @cmember empty table name => DB_E_BADTABLEID
int Variation_17();
// @cmember Maximum length for table name => S_OK
int Variation_18();
// @cmember 1 char too long table name => DB_E_BADTABLEID
int Variation_19();
// @cmember Maximum length column name => S_OK
int Variation_20();
// @cmember 1 char too long column name => DB_E_BADCOLUMNID
int Variation_21();
// @cmember ulColumnSize 0 for a variable-length column => S_OK
int Variation_22();
// @cmember For each provider type create and drop a table with a single column => S_OK
int Variation_23();
// @cmember invalid table name => DB_E_BADTABLEID
int Variation_24();
// @cmember pTableID provides the name of an existing table => DB_E_DUPLICATETABLEID
int Variation_25();
// @cmember valid riid and NULL ppRowset => S_OK
int Variation_26();
// @cmember invalid column name => DB_E_BADCOLUMNID
int Variation_27();
// @cmember invalid type name for a column (NULL, empty or inexistent)
int Variation_28();
// @cmember invalid wType for a column => DB_E_BADTYPE
int Variation_29();
// @cmember wType and pswzTypeName mismatch in a column description => DB_E_BADTYPE
int Variation_30();
// @cmember not null pTypeInfo => DB_E_BADTYPE (for the time being
int Variation_31();
// @cmember duplicate column identifiers => DB_E_DUPLICATECOLUMNID
int Variation_32();
// @cmember improper eKind value in a DBID => DB_E_BADCOLUMNID
int Variation_33();
// @cmember invalid property value on column
int Variation_34();
// @cmember Invalid column precision => DB_E_BADPRECISION
int Variation_35();
// @cmember invalid scale on column => DB_E_BADSCALE
int Variation_36();
// @cmember col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_SETIFCHEAP => DB_S_ERRORSOCCURRED
int Variation_37();
// @cmember col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_REQUIRED => DB_E_ERRORSOCCURRED
int Variation_38();
// @cmember invalid propID for a column propriety
int Variation_39();
// @cmember colid in DBPROP of a column property is ignored
int Variation_40();
// @cmember Abort retaining
int Variation_41();
// @cmember Abort without retaining
int Variation_42();
// @cmember Commit retain
int Variation_43();
// @cmember Commit non-retaining
int Variation_44();
// @cmember Autoincrementable columns
int Variation_45();
// @cmember Default values
int Variation_46();
// @cmember Column descriptions
int Variation_47();
// @cmember Variable length columns
int Variation_48();
// @cmember Nullable/non nullable columns
int Variation_49();
// @cmember Primary key column
int Variation_50();
// @cmember Unique columns
int Variation_51();
// @cmember Test conflicting properties
int Variation_52();
// @cmember Create a table and ask for a rowset, setting DBPROP_ABORTPRESERVE
int Variation_53();
// @cmember Inserting rows after table creation, using the resulting rowset
int Variation_54();
// @cmember Delete rows in the created rowset
int Variation_55();
// @cmember Aggregation, ask for IID_IUnknown
int Variation_56();
// @cmember Create a table and ask for a rowset, setting DBPROP_COMMITPRESERVE
int Variation_57();
// @cmember Create a table and ask for a rowset, setting DBPROP_OWNINSERT
int Variation_58();
// @cmember Create a table and ask for a rowset, setting DBPROP_BOOKMARKS
int Variation_59();
// @cmember Create a table and ask for a rowset, setting DBPROP_CANHOLDROWS
int Variation_60();
// @cmember Create a table and ask for a rowset, setting DBPROP_MAYWRITECOLUMN
int Variation_61();
// @cmember Ask for a rowset mandatory/optional interface when table creation => S_OK
int Variation_62();
// @cmember threads on different tables
int Variation_63();
// @cmember threads on the same table
int Variation_64();
// @cmember try all interfaces on rowset that can be returned
int Variation_65();
// @cmember create with a table property => S_OK
int Variation_66();
// @cmember create a table and update a row, using the rowset interface got => S_OK
int Variation_67();
// @cmember Fully Qualified Table Name
int Variation_68();
// @cmember Quoted table name
int Variation_69();
// @cmember Aggregation, non IID_IUnknown
int Variation_70();
// @cmember Aggregation -> IRowsetInfo::GetReferencedRowset
int Variation_71();
// @cmember Agg session -> IRowsetInfo::GetSpecification
int Variation_72();
// @cmember Table -> Agg ColumnRowset, ask for non IID_IUnknown
int Variation_73();
// @cmember Table -> Agg ColumnRowset, ask for IID_IUnknown
int Variation_74();
// @cmember Table -> Agg ColumnRowset -> IRowsetInfo::GetSpecification
int Variation_75();
// @cmember colid is ignored in a non column specific rowset property
int Variation_76();
// @cmember colid is DB_NULLID in a column specific rowset property => S_OK
int Variation_77();
// @cmember valid, non DB_NULLID colid for a column specific rowset property
int Variation_78();
// @cmember invalid colid for a column specific rowset property
int Variation_79();
// @cmember Create a table. Retrieve a rowset on it (IRowsetInfo). Check GetSpecification()
int Variation_80();
// @cmember DB_NULLID is ignored for non column-related table properties
int Variation_81();
// @cmember Column related table property set to bad colid
int Variation_82();
// @cmember How many DBTYPE_I4 columns?
int Variation_83();
// @cmember Open a rowset with CE, call IColumnRowset with an aggregated pIUnk
int Variation_84();
// @cmember Different DBKINDs for pTableID
int Variation_85();
// @cmember Different DBKINDs for column IDs
int Variation_86();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
};
// {{ TCW_TESTCASE(TCCreateTable)
#define THE_CLASS TCCreateTable
BEG_TEST_CASE(TCCreateTable, TCITableDefinition, L"TestCase for table creation")
TEST_VARIATION(1, L"Session interfaces")
TEST_VARIATION(2, L"pTableID is NULL => S_OK")
TEST_VARIATION(3, L"ppTableID is a NULL pointer => S_OK")
TEST_VARIATION(4, L"pTableID and ppTableID both NULL => E_INVALIDARG")
TEST_VARIATION(5, L"*pTableID == DB_NULLID => DB_E_BADTABLEID")
TEST_VARIATION(6, L"cColumnDesc == 0 => E_INVALIDARG or S_OK")
TEST_VARIATION(7, L"rgColumnDesc == NULL => E_INVALIDARG")
TEST_VARIATION(8, L"cPropertySets != 0 and rgPropertySets == NULL => E_INVALIDARG")
TEST_VARIATION(9, L"cPropertySets is 0 and rgPropertySets != NULL => S_OK")
TEST_VARIATION(10, L"for a property sets, cProperties != 0 and rgProperties == NULL => E_INVALIDARG")
TEST_VARIATION(11, L"cProperties == 0 on a property set => S_OK")
TEST_VARIATION(12, L"for a column, rgPropertySets is NULL though cPropertySets != 0 => E_INVALIDARG")
TEST_VARIATION(13, L"dbcid in an element of rgColumnDesc is DB_NULLID => DB_E_BADCOLUMNID")
TEST_VARIATION(14, L"dbcid in an element of rgColumnDesc is NULL => DB_E_BADCOLUMNID")
TEST_VARIATION(15, L"not null pclsid in a DBCOLUMNDESC element")
TEST_VARIATION(16, L"empty column name => DB_E_BADCOLUMNID")
TEST_VARIATION(17, L"empty table name => DB_E_BADTABLEID")
TEST_VARIATION(18, L"Maximum length for table name => S_OK")
TEST_VARIATION(19, L"1 char too long table name => DB_E_BADTABLEID")
TEST_VARIATION(20, L"Maximum length column name => S_OK")
TEST_VARIATION(21, L"1 char too long column name => DB_E_BADCOLUMNID")
TEST_VARIATION(22, L"ulColumnSize 0 for a variable-length column => S_OK")
TEST_VARIATION(23, L"For each provider type create and drop a table with a single column => S_OK")
TEST_VARIATION(24, L"invalid table name => DB_E_BADTABLEID")
TEST_VARIATION(25, L"pTableID provides the name of an existing table => DB_E_DUPLICATETABLEID")
TEST_VARIATION(26, L"valid riid and NULL ppRowset => S_OK")
TEST_VARIATION(27, L"invalid column name => DB_E_BADCOLUMNID")
TEST_VARIATION(28, L"invalid type name for a column (NULL, empty or inexistent)")
TEST_VARIATION(29, L"invalid wType for a column => DB_E_BADTYPE")
TEST_VARIATION(30, L"wType and pswzTypeName mismatch in a column description => DB_E_BADTYPE")
TEST_VARIATION(31, L"not null pTypeInfo => DB_E_BADTYPE (for the time being")
TEST_VARIATION(32, L"duplicate column identifiers => DB_E_DUPLICATECOLUMNID")
TEST_VARIATION(33, L"improper eKind value in a DBID => DB_E_BADCOLUMNID")
TEST_VARIATION(34, L"invalid property value on column")
TEST_VARIATION(35, L"Invalid column precision => DB_E_BADPRECISION")
TEST_VARIATION(36, L"invalid scale on column => DB_E_BADSCALE")
TEST_VARIATION(37, L"col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_SETIFCHEAP => DB_S_ERRORSOCCURRED")
TEST_VARIATION(38, L"col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_REQUIRED => DB_E_ERRORSOCCURRED")
TEST_VARIATION(39, L"invalid propID for a column propriety")
TEST_VARIATION(40, L"colid in DBPROP of a column property is ignored")
TEST_VARIATION(41, L"Abort retaining")
TEST_VARIATION(42, L"Abort without retaining")
TEST_VARIATION(43, L"Commit retain")
TEST_VARIATION(44, L"Commit non-retaining")
TEST_VARIATION(45, L"Autoincrementable columns")
TEST_VARIATION(46, L"Default values")
TEST_VARIATION(47, L"Column descriptions")
TEST_VARIATION(48, L"Variable length columns")
TEST_VARIATION(49, L"Nullable/non nullable columns")
TEST_VARIATION(50, L"Primary key column")
TEST_VARIATION(51, L"Unique columns")
TEST_VARIATION(52, L"Test conflicting properties")
TEST_VARIATION(53, L"Create a table and ask for a rowset, setting DBPROP_ABORTPRESERVE")
TEST_VARIATION(54, L"Inserting rows after table creation, using the resulting rowset")
TEST_VARIATION(55, L"Delete rows in the created rowset")
TEST_VARIATION(56, L"Aggregation, ask for IID_IUnknown")
TEST_VARIATION(57, L"Create a table and ask for a rowset, setting DBPROP_COMMITPRESERVE")
TEST_VARIATION(58, L"Create a table and ask for a rowset, setting DBPROP_OWNINSERT")
TEST_VARIATION(59, L"Create a table and ask for a rowset, setting DBPROP_BOOKMARKS")
TEST_VARIATION(60, L"Create a table and ask for a rowset, setting DBPROP_CANHOLDROWS")
TEST_VARIATION(61, L"Create a table and ask for a rowset, setting DBPROP_MAYWRITECOLUMN")
TEST_VARIATION(62, L"Ask for a rowset mandatory/optional interface when table creation => S_OK")
TEST_VARIATION(63, L"threads on different tables")
TEST_VARIATION(64, L"threads on the same table")
TEST_VARIATION(65, L"try all interfaces on rowset that can be returned")
TEST_VARIATION(66, L"create with a table property => S_OK")
TEST_VARIATION(67, L"create a table and update a row, using the rowset interface got => S_OK")
TEST_VARIATION(68, L"Fully Qualified Table Name")
TEST_VARIATION(69, L"Quoted table name")
TEST_VARIATION(70, L"Aggregation, non IID_IUnknown")
TEST_VARIATION(71, L"Aggregation -> IRowsetInfo::GetReferencedRowset")
TEST_VARIATION(72, L"Agg session -> IRowsetInfo::GetSpecification")
TEST_VARIATION(73, L"Table -> Agg ColumnRowset, ask for non IID_IUnknown")
TEST_VARIATION(74, L"Table -> Agg ColumnRowset, ask for IID_IUnknown")
TEST_VARIATION(75, L"Table -> Agg ColumnRowset -> IRowsetInfo::GetSpecification")
TEST_VARIATION(76, L"colid is ignored in a non column specific rowset property")
TEST_VARIATION(77, L"colid is DB_NULLID in a column specific rowset property => S_OK")
TEST_VARIATION(78, L"valid, non DB_NULLID colid for a column specific rowset property")
TEST_VARIATION(79, L"invalid colid for a column specific rowset property")
TEST_VARIATION(80, L"Create a table. Retrieve a rowset on it (IRowsetInfo). Check GetSpecification()")
TEST_VARIATION(81, L"DB_NULLID is ignored for non column-related table properties")
TEST_VARIATION(82, L"Column related table property set to bad colid")
TEST_VARIATION(83, L"How many DBTYPE_I4 columns?")
TEST_VARIATION(84, L"Open a rowset with CE, call IColumnRowset with an aggregated pIUnk")
TEST_VARIATION(85, L"Different DBKINDs for pTableID")
TEST_VARIATION(86, L"Different DBKINDs for column IDs")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(RODataSource)
//--------------------------------------------------------------------
// @class Test case for operating on a read only data source
//
class RODataSource : public TCDropColumn {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
IUnknown *m_pIUnknown;
IUnknown *m_pIUnknown2;
ITableDefinition *m_pITableDefinition2;
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(RODataSource,TCDropColumn);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Add a column
int Variation_1();
// @cmember Drop a column
int Variation_2();
// @cmember Create a table
int Variation_3();
// @cmember Drop a table
int Variation_4();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(RODataSource)
#define THE_CLASS RODataSource
BEG_TEST_CASE(RODataSource, TCDropColumn, L"Test case for operating on a read only data source")
TEST_VARIATION(1, L"Add a column")
TEST_VARIATION(2, L"Drop a column")
TEST_VARIATION(3, L"Create a table")
TEST_VARIATION(4, L"Drop a table")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_Boundary)
//*-----------------------------------------------------------------------
// @class General and boundary/null test for ITableDefinitionWithConstraints::AddConstraint
//
class TCAddConstraint_Boundary : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_Boundary,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Check the session object (QI for interfaces)
int Variation_1();
// @cmember pTableID is NULL => E_INVALIDARG
int Variation_2();
// @cmember *pTableID is DB_NULLID => DB_E_NOTABLE
int Variation_3();
// @cmember Table name is NULL => DB_E_NOTABLE
int Variation_4();
// @cmember Table name is the empty string => DB_E_NOTABLE
int Variation_5();
// @cmember Table name has maximum length
int Variation_6();
// @cmember Table name exceeds maximum length => DB_E_NOTABLE
int Variation_7();
// @cmember Table name contains illegal characters
int Variation_8();
// @cmember Invalid DBKIND value for the base table
int Variation_9();
// @cmember NULL column list in a constraint, column size is not 0 => E_INVALIDARG
int Variation_10();
// @cmember NULL column name in a constraint
int Variation_11();
// @cmember Empty string for a column name
int Variation_12();
// @cmember Maximum length column name in a constraint
int Variation_13();
// @cmember Column name exceeds maximum length
int Variation_14();
// @cmember Invalid DBKIND for a column DBID of a constraint
int Variation_15();
// @cmember Column ID is DB_NULLID
int Variation_16();
// @cmember NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)
int Variation_17();
// @cmember DBNULL_ID *pReferencedTableID for a foreign key constraint
int Variation_18();
// @cmember NULL referenced table name for a foreign key constraint
int Variation_19();
// @cmember Emptry string referenced table name for a foreign key constraint
int Variation_20();
// @cmember Maximum length referenced table name for a foreign key constraint
int Variation_21();
// @cmember Referenced table name longer than allowed for a foreign key constraint
int Variation_22();
// @cmember Illegal characters in the referenced table name for a foreign key constraint
int Variation_23();
// @cmember Bad constraint type
int Variation_24();
// @cmember Empty list of columns for a unique, primay key or foreign key constraint
int Variation_25();
// @cmember Non empty list of columns for a check constraint
int Variation_26();
// @cmember Not null pwszConstraintText in a unique, PK or FK constraint
int Variation_27();
// @cmember NULL pConstraintDesc => E_INVALIDARG
int Variation_28();
// @cmember 0 < cColumns and NULL == rgColumnList => E_INVALIDARG
int Variation_29();
// @cmember 0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG
int Variation_30();
// @cmember Constraint is not foreign key and pReferencedTableID is not NULL
int Variation_31();
// @cmember Non empty list of foreign keys for a constraint that is not foreign key
int Variation_32();
// @cmember Inexistent referenced table
int Variation_33();
// @cmember Add several constraints to the table
int Variation_34();
// @cmember Inexistent table name => DB_E_NOTABLE
int Variation_35();
// @cmember Inexistent column name => DB_E_NOCOLUMN
int Variation_36();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_Boundary)
#define THE_CLASS TCAddConstraint_Boundary
BEG_TEST_CASE(TCAddConstraint_Boundary, TCITableDefinition, L"General and boundary/null test for ITableDefinitionWithConstraints::AddConstraint")
TEST_VARIATION(1, L"Check the session object (QI for interfaces)")
TEST_VARIATION(2, L"pTableID is NULL => E_INVALIDARG")
TEST_VARIATION(3, L"*pTableID is DB_NULLID => DB_E_NOTABLE")
TEST_VARIATION(4, L"Table name is NULL => DB_E_NOTABLE")
TEST_VARIATION(5, L"Table name is the empty string => DB_E_NOTABLE")
TEST_VARIATION(6, L"Table name has maximum length")
TEST_VARIATION(7, L"Table name exceeds maximum length => DB_E_NOTABLE")
TEST_VARIATION(8, L"Table name contains illegal characters")
TEST_VARIATION(9, L"Invalid DBKIND value for the base table")
TEST_VARIATION(10, L"NULL column list in a constraint, column size is not 0 => E_INVALIDARG")
TEST_VARIATION(11, L"NULL column name in a constraint")
TEST_VARIATION(12, L"Empty string for a column name")
TEST_VARIATION(13, L"Maximum length column name in a constraint")
TEST_VARIATION(14, L"Column name exceeds maximum length")
TEST_VARIATION(15, L"Invalid DBKIND for a column DBID of a constraint")
TEST_VARIATION(16, L"Column ID is DB_NULLID")
TEST_VARIATION(17, L"NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)")
TEST_VARIATION(18, L"DBNULL_ID *pReferencedTableID for a foreign key constraint")
TEST_VARIATION(19, L"NULL referenced table name for a foreign key constraint")
TEST_VARIATION(20, L"Emptry string referenced table name for a foreign key constraint")
TEST_VARIATION(21, L"Maximum length referenced table name for a foreign key constraint")
TEST_VARIATION(22, L"Referenced table name longer than allowed for a foreign key constraint")
TEST_VARIATION(23, L"Illegal characters in the referenced table name for a foreign key constraint")
TEST_VARIATION(24, L"Bad constraint type")
TEST_VARIATION(25, L"Empty list of columns for a unique, primay key or foreign key constraint")
TEST_VARIATION(26, L"Non empty list of columns for a check constraint")
TEST_VARIATION(27, L"Not null pwszConstraintText in a unique, PK or FK constraint")
TEST_VARIATION(28, L"NULL pConstraintDesc => E_INVALIDARG")
TEST_VARIATION(29, L"0 < cColumns and NULL == rgColumnList => E_INVALIDARG")
TEST_VARIATION(30, L"0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG")
TEST_VARIATION(31, L"Constraint is not foreign key and pReferencedTableID is not NULL")
TEST_VARIATION(32, L"Non empty list of foreign keys for a constraint that is not foreign key")
TEST_VARIATION(33, L"Inexistent referenced table")
TEST_VARIATION(34, L"Add several constraints to the table")
TEST_VARIATION(35, L"Inexistent table name => DB_E_NOTABLE")
TEST_VARIATION(36, L"Inexistent column name => DB_E_NOCOLUMN")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_UNIQUE)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE
//
class TCAddConstraint_UNIQUE : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_UNIQUE,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Create a table and try to apply the constraint on each column
int Variation_1();
// @cmember Set a unique constraint on each type of column
int Variation_2();
// @cmember Create a unique constraint that uses several columns
int Variation_3();
// @cmember Create several unique constraints on a table, no overlapping
int Variation_4();
// @cmember Create multiple, overlapping constraints on a table
int Variation_5();
// @cmember Create a constraint, drop it and recreate it
int Variation_6();
// @cmember Create a constraint on a null column
int Variation_7();
// @cmember Create a contraint on a not nullable column
int Variation_8();
// @cmember Create a constraint on a column that has a default value
int Variation_9();
// @cmember Create a constraint on a column defined as a primary key
int Variation_10();
// @cmember Create a constraint on a column defined as a foreign key
int Variation_11();
// @cmember Create a constraint on a column that is included in an index
int Variation_12();
// @cmember Use the name of an already existing constraint
int Variation_13();
// @cmember Constraint is created in a different catalog
int Variation_14();
// @cmember create a unique constraint on a non empty table
int Variation_15();
// @cmember Create a unique constraints on a column that has doubled values
int Variation_16();
// @cmember Abort retaining
int Variation_17();
// @cmember Abort non retaining
int Variation_18();
// @cmember Commit retaining
int Variation_19();
// @cmember Commit non retaining
int Variation_20();
// @cmember Maximum columns allowed in Unique constraint
int Variation_21();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_UNIQUE)
#define THE_CLASS TCAddConstraint_UNIQUE
BEG_TEST_CASE(TCAddConstraint_UNIQUE, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE")
TEST_VARIATION(1, L"Create a table and try to apply the constraint on each column")
TEST_VARIATION(2, L"Set a unique constraint on each type of column")
TEST_VARIATION(3, L"Create a unique constraint that uses several columns")
TEST_VARIATION(4, L"Create several unique constraints on a table, no overlapping")
TEST_VARIATION(5, L"Create multiple, overlapping constraints on a table")
TEST_VARIATION(6, L"Create a constraint, drop it and recreate it")
TEST_VARIATION(7, L"Create a constraint on a null column")
TEST_VARIATION(8, L"Create a contraint on a not nullable column")
TEST_VARIATION(9, L"Create a constraint on a column that has a default value")
TEST_VARIATION(10, L"Create a constraint on a column defined as a primary key")
TEST_VARIATION(11, L"Create a constraint on a column defined as a foreign key")
TEST_VARIATION(12, L"Create a constraint on a column that is included in an index")
TEST_VARIATION(13, L"Use the name of an already existing constraint")
TEST_VARIATION(14, L"Constraint is created in a different catalog")
TEST_VARIATION(15, L"create a unique constraint on a non empty table")
TEST_VARIATION(16, L"Create a unique constraints on a column that has doubled values")
TEST_VARIATION(17, L"Abort retaining")
TEST_VARIATION(18, L"Abort non retaining")
TEST_VARIATION(19, L"Commit retaining")
TEST_VARIATION(20, L"Commit non retaining")
TEST_VARIATION(21, L"Maximum columns allowed in unique constraint")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_PRIMARYKEY)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_PRIMARYKEY
//
class TCAddConstraint_PRIMARYKEY : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_PRIMARYKEY,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Create a table and try to apply the constraint on each column
int Variation_1();
// @cmember Set a primary key constraint on each type of column
int Variation_2();
// @cmember Create a primary key constraint. Drop it. Create a primary key using the same name as before.
int Variation_3();
// @cmember Create multiple-columned primary key
int Variation_4();
// @cmember Create multiple primary key constraints using successive calls
int Variation_5();
// @cmember Successive calls, lists of columns overlap
int Variation_6();
// @cmember Primary key constraint on a nullable column
int Variation_7();
// @cmember Primary key constraint on a not nullable column
int Variation_8();
// @cmember Primary key constraint on a column with a default value
int Variation_9();
// @cmember Primary key constraint on a column defined as unique
int Variation_10();
// @cmember Primary key constraint on a column defined as primary key => DB_E_DUPLICATECONSTRAINTID
int Variation_11();
// @cmember Primary key constraint on a column that already has a primary key constraint
int Variation_12();
// @cmember Primary key constraint on a column that is part of a foreign key constraint
int Variation_13();
// @cmember Primary key constraint on a column that is part of an index
int Variation_14();
// @cmember Primary key constraint on a column on a not empty table
int Variation_15();
// @cmember Primary key constraint on a column that already has duplicates (for the whole key)
int Variation_16();
// @cmember Primary key constraint that has duplicates for a column in the key, but not for the whole key
int Variation_17();
// @cmember Abort retaining
int Variation_18();
// @cmember Abort non retaining
int Variation_19();
// @cmember Commit retaining
int Variation_20();
// @cmember Commit non retaining
int Variation_21();
// @cmember Create PK in different catalog
int Variation_22();
// @cmember Find maximum limit on PKs
int Variation_23();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_PRIMARYKEY)
#define THE_CLASS TCAddConstraint_PRIMARYKEY
BEG_TEST_CASE(TCAddConstraint_PRIMARYKEY, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_PRIMARYKEY")
TEST_VARIATION(1, L"Create a table and try to apply the constraint on each column")
TEST_VARIATION(2, L"Set a primary key constraint on each type of column")
TEST_VARIATION(3, L"Create a primary key constraint. Drop it. Create a primary key using the same name as before.")
TEST_VARIATION(4, L"Create multiple-columned primary key")
TEST_VARIATION(5, L"Create multiple primary key constraints using successive calls")
TEST_VARIATION(6, L"Successive calls, lists of columns overlap")
TEST_VARIATION(7, L"Primary key constraint on a nullable column -> E_FAIL")
TEST_VARIATION(8, L"Primary key constraint on a not nullable column")
TEST_VARIATION(9, L"Primary key constraint on a column with a default value")
TEST_VARIATION(10, L"Primary key constraint on a column defined as unique")
TEST_VARIATION(11, L"Primary key constraint on a column defined as primary key => DB_E_DUPLICATECONSTRAINTID")
TEST_VARIATION(12, L"Primary key constraint on a column that already has a primary key constraint")
TEST_VARIATION(13, L"Primary key constraint on a column that is part of a foreign key constraint")
TEST_VARIATION(14, L"Primary key constraint on a column that is part of an index")
TEST_VARIATION(15, L"Primary key constraint on a column on a not empty table")
TEST_VARIATION(16, L"Primary key constraint on a column that already has duplicates (for the whole key)")
TEST_VARIATION(17, L"Primary key constraint that has duplicates for a column in the key, but not for the whole key")
TEST_VARIATION(18, L"Abort retaining")
TEST_VARIATION(19, L"Abort non retaining")
TEST_VARIATION(20, L"Commit retaining")
TEST_VARIATION(21, L"Commit non retaining")
TEST_VARIATION(22, L"Create primary key in a different catalog")
TEST_VARIATION(23, L"Find how many columns are supported in a PK")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_FOREIGNKEY)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_FOREIGNKEY
//
class TCAddConstraint_FOREIGNKEY : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
CTable *m_pReferenceTable;
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_FOREIGNKEY,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Simple foreign key constraint
int Variation_1();
// @cmember Foregin key is made of several columns
int Variation_2();
// @cmember Multiple foreign key constraints on a table
int Variation_3();
// @cmember Multiple overlapping foreign key constraints
int Variation_4();
// @cmember Create a foreign key on each column of the table
int Variation_5();
// @cmember Create a foreign key on all columns
int Variation_6();
// @cmember Create foreign key and try to drop the reference table
int Variation_7();
// @cmember On a nullable column
int Variation_8();
// @cmember On a not nullable column
int Variation_9();
// @cmember On a column having a default value
int Variation_10();
// @cmember On a column defined as unique
int Variation_11();
// @cmember On a primary key column
int Variation_12();
// @cmember On a column that is part of the index
int Variation_13();
// @cmember On a table that is in another catalog
int Variation_14();
// @cmember Use different combination for update/delete rules, as well as match type
int Variation_15();
// @cmember Referenced table name and base table names have maximum length
int Variation_16();
// @cmember Columns in the foreign key (base table and reference table) have different names
int Variation_17();
// @cmember Different size in column lists (base table and referenced)
int Variation_18();
// @cmember Column types in base table and reference table are different
int Variation_19();
// @cmember Invalid value for the update rule
int Variation_20();
// @cmember Invalid value for the delete rule
int Variation_21();
// @cmember Invalid value for the MatchType
int Variation_22();
// @cmember Inexistent column names in the referenced table
int Variation_23();
// @cmember Inexistent column name in the base table
int Variation_24();
// @cmember Inexistent base table
int Variation_25();
// @cmember Inexistent reference table
int Variation_26();
// @cmember NULL pConstraintID
int Variation_27();
// @cmember Referenced col list is not a unique / pk constraint => failure
int Variation_28();
// @cmember Create a foreign key and then insert a NULL value for one of the fk columns
int Variation_29();
// @cmember The referenced table and the base table are the same
int Variation_30();
// @cmember The base and referenced tables are temporary tables
int Variation_31();
// @cmember Base table is a temporary table
int Variation_32();
// @cmember Abort retaining
int Variation_33();
// @cmember Abort non retaining
int Variation_34();
// @cmember Commit retaining
int Variation_35();
// @cmember Commit non retaining
int Variation_36();
// @cmember The base table is already populated and the referenced one is empty => DB_E_SCHEMAVIOLATION
int Variation_37();
// @cmember Find maximum columns allowed in foreign keys
int Variation_38();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_FOREIGNKEY)
#define THE_CLASS TCAddConstraint_FOREIGNKEY
BEG_TEST_CASE(TCAddConstraint_FOREIGNKEY, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_FOREIGNKEY")
TEST_VARIATION(1, L"Simple foreign key constraint")
TEST_VARIATION(2, L"Foregin key is made of several columns")
TEST_VARIATION(3, L"Multiple foreign key constraints on a table")
TEST_VARIATION(4, L"Multiple overlapping foreign key constraints")
TEST_VARIATION(5, L"Create a foreign key on each column of the table")
TEST_VARIATION(6, L"Create a foreign key on all columns")
TEST_VARIATION(7, L"Create foreign key and try to drop the reference table")
TEST_VARIATION(8, L"On a nullable column")
TEST_VARIATION(9, L"On a not nullable column")
TEST_VARIATION(10, L"On a column having a default value")
TEST_VARIATION(11, L"On a column defined as unique")
TEST_VARIATION(12, L"On a primary key column")
TEST_VARIATION(13, L"On a column that is part of the index")
TEST_VARIATION(14, L"On a table that is in another catalog")
TEST_VARIATION(15, L"Use different combination for update/delete rules, as well as match type")
TEST_VARIATION(16, L"Referenced table name and base table names have maximum length")
TEST_VARIATION(17, L"Columns in the foreign key (base table and reference table) have different names")
TEST_VARIATION(18, L"Different size in column lists (base table and referenced)")
TEST_VARIATION(19, L"Column types in base table and reference table are different")
TEST_VARIATION(20, L"Invalid value for the update rule")
TEST_VARIATION(21, L"Invalid value for the delete rule")
TEST_VARIATION(22, L"Invalid value for the MatchType")
TEST_VARIATION(23, L"Inexistent column names in the referenced table")
TEST_VARIATION(24, L"Inexistent column name in the base table")
TEST_VARIATION(25, L"Inexistent base table")
TEST_VARIATION(26, L"Inexistent reference table")
TEST_VARIATION(27, L"NULL pConstraintID")
TEST_VARIATION(28, L"Referenced col list is not a unique / pk constraint => failure")
TEST_VARIATION(29, L"Create a foreign key and then insert a NULL value for one of the fk columns")
TEST_VARIATION(30, L"The referenced table and the base table are the same")
TEST_VARIATION(31, L"The base and referenced tables are temporary tables")
TEST_VARIATION(32, L"Base table is a temporary table")
TEST_VARIATION(33, L"Abort retaining")
TEST_VARIATION(34, L"Abort non retaining")
TEST_VARIATION(35, L"Commit retaining")
TEST_VARIATION(36, L"Commit non retaining")
TEST_VARIATION(37, L"The base table is already populated and the referenced one is empty => DB_E_SCHEMAVIOLATION")
TEST_VARIATION(38, L"Find maximum columns allowed in foreign keys")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_CHECK)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE
//
class TCAddConstraint_CHECK : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_CHECK,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Add simple check constraint
int Variation_1();
// @cmember Add 2 check constraints on the same column
int Variation_2();
// @cmember Add check constraint for each column
int Variation_3();
// @cmember Check constraint is always TRUE
int Variation_4();
// @cmember Check constraint is always false
int Variation_5();
// @cmember Long text for the check constraint
int Variation_6();
// @cmember Check constraint is made of white characters
int Variation_7();
// @cmember Maximum length for the table name
int Variation_8();
// @cmember Create the constraint, drop it, readd it with different text
int Variation_9();
// @cmember Use inexistent column names in the check constraint
int Variation_10();
// @cmember Use qualified table column with different table
int Variation_11();
// @cmember Set a check condition on an index column
int Variation_12();
// @cmember pwszConstraintText is NULL
int Variation_13();
// @cmember pwszConstraintText is an empty string
int Variation_14();
// @cmember Abort retaining
int Variation_15();
// @cmember Abort non retaining
int Variation_16();
// @cmember Commit retaining
int Variation_17();
// @cmember Commit non retaining
int Variation_18();
// @cmember Table is populated with rows that break the constraint to be added => DB_E_SCHEMAVIOLATION
int Variation_19();
// @cmember Create check constraint in different catalog
int Variation_20();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_CHECK)
#define THE_CLASS TCAddConstraint_CHECK
BEG_TEST_CASE(TCAddConstraint_CHECK, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE")
TEST_VARIATION(1, L"Add simple check constraint")
TEST_VARIATION(2, L"Add 2 check constraints on the same column")
TEST_VARIATION(3, L"Add check constraint for each column")
TEST_VARIATION(4, L"Check constraint is always TRUE")
TEST_VARIATION(5, L"Check constraint is always false")
TEST_VARIATION(6, L"Long text for the check constraint")
TEST_VARIATION(7, L"Check constraint is made of white characters")
TEST_VARIATION(8, L"Maximum length for the table name")
TEST_VARIATION(9, L"Create the constraint, drop it, readd it with different text")
TEST_VARIATION(10, L"Use inexistent column names in the check constraint")
TEST_VARIATION(11, L"Use qualified table column with different table")
TEST_VARIATION(12, L"Set a check condition on an index column")
TEST_VARIATION(13, L"pwszConstraintText is NULL")
TEST_VARIATION(14, L"pwszConstraintText is an empty string")
TEST_VARIATION(15, L"Abort retaining")
TEST_VARIATION(16, L"Abort non retaining")
TEST_VARIATION(17, L"Commit retaining")
TEST_VARIATION(18, L"Commit non retaining")
TEST_VARIATION(19, L"Table is populated with rows that break the constraint to be added => DB_E_SCHEMAVIOLATION")
TEST_VARIATION(20, L"Check constraint is created on a table in different catalog")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_Deferrability)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting
//
class TCAddConstraint_Deferrability : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_Deferrability,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Immediate unique constraint
int Variation_1();
// @cmember Defferable unique constraint
int Variation_2();
// @cmember Deffered unique constraint
int Variation_3();
// @cmember Bad deferrability value unique constraint
int Variation_4();
// @cmember Immediate primary key constraint
int Variation_5();
// @cmember Deferrable primary key constraint
int Variation_6();
// @cmember Deferred primary key constraint
int Variation_7();
// @cmember Bad deferrability value primary key constraint
int Variation_8();
// @cmember Immediate foreign key constraint
int Variation_9();
// @cmember Deferrable foreign key constraint
int Variation_10();
// @cmember Deferred foreign key constraint
int Variation_11();
// @cmember Bad deferrability value foreign key constraint
int Variation_12();
// @cmember Immediate check constraint
int Variation_13();
// @cmember Deferrable check constraint
int Variation_14();
// @cmember Deferred check constraint
int Variation_15();
// @cmember Bad deferrability value check constraint
int Variation_16();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCAddConstraint_Deferrability)
#define THE_CLASS TCAddConstraint_Deferrability
BEG_TEST_CASE(TCAddConstraint_Deferrability, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting")
TEST_VARIATION(1, L"Immediate unique constraint")
TEST_VARIATION(2, L"Defferable unique constraint")
TEST_VARIATION(3, L"Deffered unique constraint")
TEST_VARIATION(4, L"Bad deferrability value unique constraint")
TEST_VARIATION(5, L"Immediate primary key constraint")
TEST_VARIATION(6, L"Deferrable primary key constraint")
TEST_VARIATION(7, L"Deferred primary key constraint")
TEST_VARIATION(8, L"Bad deferrability value primary key constraint")
TEST_VARIATION(9, L"Immediate foreign key constraint")
TEST_VARIATION(10, L"Deferrable foreign key constraint")
TEST_VARIATION(11, L"Deferred foreign key constraint")
TEST_VARIATION(12, L"Bad deferrability value foreign key constraint")
TEST_VARIATION(13, L"Immediate check constraint")
TEST_VARIATION(14, L"Deferrable check constraint")
TEST_VARIATION(15, L"Deferred check constraint")
TEST_VARIATION(16, L"Bad deferrability value check constraint")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCCreateTableWithConstraints_NoConstraint)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting
//
class TCCreateTableWithConstraints_NoConstraint : public TCCreateTable {
public:
//DECLARE_TEST_CASE_DATA();
ITableDefinitionWithConstraints *m_pITableDefinitionWithConstraints;
public:
static const WCHAR m_wszTestCaseName[];
static const WCHAR m_wszTestCaseDesc[];
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCreateTableWithConstraints_NoConstraint,TCCreateTable);
// }} TCW_DECLARE_FUNCS_END
// @member Create the table using ITableDefinition::CreateTable and check its creation
virtual HRESULT CreateAndCheckTable(
ITableDefinition *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinition interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDesc, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
);
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCCreateTableWithConstraints_NoConstraint)
//#define THE_CLASS TCCreateTableWithConstraints_NoConstraint
//BEG_TEST_CASE(TCCreateTableWithConstraints_NoConstraint, TCCreateTable, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting")
//END_TEST_CASE()
//#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
const WCHAR TCCreateTableWithConstraints_NoConstraint::m_wszTestCaseName[] = { L"TCCreateTableWithConstraints_NoConstraint" };
const WCHAR TCCreateTableWithConstraints_NoConstraint::m_wszTestCaseDesc[] = { L"Testcase for ITableDefinitionWithConstraints::CreateTable when no constraints are specified => should expect the same results as for ITableDefinition::CreateTable" };
// {{ TCW_TEST_CASE_MAP(TCCreateTableWithConstraints)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints when constraints are set
//
class TCCreateTableWithConstraints : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCreateTableWithConstraints,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Create a table and multiple constraint of various types
int Variation_1();
// @cmember Table with a unique constraint (on a single column)
int Variation_2();
// @cmember Table with a unique constraint (on multiple columns)
int Variation_3();
// @cmember Table with a primary key constraint (on a single column)
int Variation_4();
// @cmember Table with a primary key constraint (on multiple columns)
int Variation_5();
// @cmember Table with a foreign key constraint (single column)
int Variation_6();
// @cmember Table with foreign key constraint defined on multiple keys
int Variation_7();
// @cmember Table with a simple check constraint
int Variation_8();
// @cmember Table with multiple unique constraints defined
int Variation_9();
// @cmember Table with unique constraint and foreign key
int Variation_10();
// @cmember Table with primary key and check constraint
int Variation_11();
// @cmember Deferrable, immediate constraints
int Variation_12();
// @cmember Deferred constraints
int Variation_13();
// @cmember Abort retain
int Variation_14();
// @cmember Abort non retain
int Variation_15();
// @cmember Commit retain
int Variation_16();
// @cmember Commit non retain
int Variation_17();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCCreateTableWithConstraints)
#define THE_CLASS TCCreateTableWithConstraints
BEG_TEST_CASE(TCCreateTableWithConstraints, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints when constraints are set")
TEST_VARIATION(1, L"Create a table and multiple constraint of various types")
TEST_VARIATION(2, L"Table with a unique constraint (on a single column)")
TEST_VARIATION(3, L"Table with a unique constraint (on multiple columns)")
TEST_VARIATION(4, L"Table with a primary key constraint (on a single column)")
TEST_VARIATION(5, L"Table with a primary key constraint (on multiple columns)")
TEST_VARIATION(6, L"Table with a foreign key constraint (single column)")
TEST_VARIATION(7, L"Table with foreign key constraint defined on multiple keys")
TEST_VARIATION(8, L"Table with a simple check constraint")
TEST_VARIATION(9, L"Table with multiple unique constraints defined")
TEST_VARIATION(10, L"Table with unique constraint and foreign key")
TEST_VARIATION(11, L"Table with primary key and check constraint")
TEST_VARIATION(12, L"Deferrable, immediate constraints")
TEST_VARIATION(13, L"Deferred constraints")
TEST_VARIATION(14, L"Abort retain")
TEST_VARIATION(15, L"Abort non retain")
TEST_VARIATION(16, L"Commit retain")
TEST_VARIATION(17, L"Commit non retain")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCCreateTableWithConstraints_Boundary)
//*-----------------------------------------------------------------------
// @class Boundary and NULL testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints
//
class TCCreateTableWithConstraints_Boundary : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCreateTableWithConstraints_Boundary,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember 0 < cConstraintDescs and NULL == rgConstraintDescs => E_INVALIDARG
int Variation_1();
// @cmember 0 == cConstraintDescs and NULL != rgConstraintDescs => S_OK
int Variation_2();
// @cmember pTableID is NULL ppTableID is not NULL => S_OK
int Variation_3();
// @cmember Bad DBKIND of a constraint ID
int Variation_4();
// @cmember NULL pConstraintID in a constraint
int Variation_5();
// @cmember NULL column list in a constraint, column size is not 0 => E_INVALIDARG
int Variation_6();
// @cmember Empty list of columns for a unique, primay key or foreign key constraint
int Variation_7();
// @cmember Non empty list of columns for a check constraint
int Variation_8();
// @cmember Non empty list of foreign keys for a constraint that is not foreign key
int Variation_9();
// @cmember 0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG
int Variation_10();
// @cmember Constraint is not foreign key and pReferencedTableID is not NULL
int Variation_11();
// @cmember NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)
int Variation_12();
// @cmember NULL referenced table name for a foreign key constraint
int Variation_13();
// @cmember DB_NULLID *pReferencedTableID for a foreign key constraint
int Variation_14();
// @cmember Empty string referenced table name for a foreign key constraint
int Variation_15();
// @cmember Maximum length referenced table name for a foreign key constraint
int Variation_16();
// @cmember Referenced table name longer than allowed for a foreign key constraint
int Variation_17();
// @cmember Illegal characters in the referenced table name for a foreign key constraint
int Variation_18();
// @cmember Bad constraint type
int Variation_19();
// @cmember Inexistent referenced table
int Variation_20();
// @cmember Empty string for a column name
int Variation_21();
// @cmember Maximum length column name in a constraint
int Variation_22();
// @cmember Invalid DBKIND for a column DBID of a constraint
int Variation_23();
// @cmember Column ID is DB_NULLID
int Variation_24();
// @cmember Inexistent column => DB_E_NOCOLUMN
int Variation_25();
// @cmember NULL column name => DB_E_NOCOLUMN
int Variation_26();
// @cmember Column name exceeds maximum length name
int Variation_27();
// @cmember Invalid column name
int Variation_28();
// @cmember Existent table name => DB_E_DUPLICATETABLEID
int Variation_29();
// @cmember Same constraint name in 2 constraints => DB_E_DUPLICATECONSTRAINTID
int Variation_30();
// @cmember NULL pConstraintID in 2 constraints => S_OK
int Variation_31();
// @cmember Try to create table with constraints, but table already exists => DB_E_DUPLICATEDTABLEID
int Variation_32();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCCreateTableWithConstraints_Boundary)
#define THE_CLASS TCCreateTableWithConstraints_Boundary
BEG_TEST_CASE(TCCreateTableWithConstraints_Boundary, TCITableDefinition, L"Boundary and NULL testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints")
TEST_VARIATION(1, L"0 < cConstraintDescs and NULL == rgConstraintDescs => E_INVALIDARG")
TEST_VARIATION(2, L"0 == cConstraintDescs and NULL != rgConstraintDescs => S_OK")
TEST_VARIATION(3, L"pTableID is NULL ppTableID is not NULL => S_OK")
TEST_VARIATION(4, L"Bad DBKIND of a constraint ID")
TEST_VARIATION(5, L"NULL pConstraintID in a constraint")
TEST_VARIATION(6, L"NULL column list in a constraint, column size is not 0 => E_INVALIDARG")
TEST_VARIATION(7, L"Empty list of columns for a unique, primay key or foreign key constraint")
TEST_VARIATION(8, L"Non empty list of columns for a check constraint")
TEST_VARIATION(9, L"Non empty list of foreign keys for a constraint that is not foreign key")
TEST_VARIATION(10, L"0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG")
TEST_VARIATION(11, L"Constraint is not foreign key and pReferencedTableID is not NULL")
TEST_VARIATION(12, L"NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)")
TEST_VARIATION(13, L"NULL referenced table name for a foreign key constraint")
TEST_VARIATION(14, L"DB_NULLID *pReferencedTableID for a foreign key constraint")
TEST_VARIATION(15, L"Empty string referenced table name for a foreign key constraint")
TEST_VARIATION(16, L"Maximum length referenced table name for a foreign key constraint")
TEST_VARIATION(17, L"Referenced table name longer than allowed for a foreign key constraint")
TEST_VARIATION(18, L"Illegal characters in the referenced table name for a foreign key constraint")
TEST_VARIATION(19, L"Bad constraint type")
TEST_VARIATION(20, L"Inexistent referenced table")
TEST_VARIATION(21, L"Empty string for a column name")
TEST_VARIATION(22, L"Maximum length column name in a constraint")
TEST_VARIATION(23, L"Invalid DBKIND for a column DBID of a constraint")
TEST_VARIATION(24, L"Column ID is DB_NULLID")
TEST_VARIATION(25, L"Inexistent column => DB_E_NOCOLUMN")
TEST_VARIATION(26, L"NULL column name => DB_E_NOCOLUMN")
TEST_VARIATION(27, L"Column name exceeds maximum length name")
TEST_VARIATION(28, L"Invalid column name")
TEST_VARIATION(29, L"Existent table name => DB_E_DUPLICATETABLEID")
TEST_VARIATION(30, L"Same constraint name in 2 constraints => DB_E_DUPLICATECONSTRAINTID")
TEST_VARIATION(31, L"NULL pConstraintID in 2 constraints => S_OK")
TEST_VARIATION(32, L"Try to create table with constraints, but table already exists => DB_E_DUPLICATEDTABLEID")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCDropConstraint)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::DropConstraint
//
class TCDropConstraint : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCDropConstraint,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember pTableID is NULL => E_INVALIDARG
int Variation_1();
// @cmember pTableID.uName.pwszName is NULL => DB_E_BADTABLEID
int Variation_2();
// @cmember Table name is empty => DB_E_BADTABLEID
int Variation_3();
// @cmember Table name is not the one on which the column was created
int Variation_4();
// @cmember Inexistent table name => DB_E_NOTABLE
int Variation_5();
// @cmember Maximum table name => S_OK
int Variation_6();
// @cmember Invalid characters in table's name => DB_E_BADTABLEID
int Variation_7();
// @cmember pConstraintID is NUL => E_INVALIDARG
int Variation_8();
// @cmember *pConstraintID is DB_NULLID => DB_E_NOCONSTRAINT
int Variation_9();
// @cmember Invalid DBKIND in the constraint name => DB_E_NOCONSTRAINT
int Variation_10();
// @cmember NULL constraint name => DB_E_NOCONSTRAINT
int Variation_11();
// @cmember Constraint name is empty string => DB_E_NOCONSTRAINT
int Variation_12();
// @cmember Inexistent constraint name => DB_E_NOCONSTRAINT
int Variation_13();
// @cmember Drop a constraint twice
int Variation_14();
// @cmember Drop a unique constraint
int Variation_15();
// @cmember Drop a primary key constraint
int Variation_16();
// @cmember Drop a foreign key constraint
int Variation_17();
// @cmember Drop a check constraint
int Variation_18();
// @cmember Create several constraints, drop a single constraint
int Variation_19();
// @cmember Drop a unique constraint in the referenced table, after the foreign key constraint was added
int Variation_20();
// @cmember Try to drop a unique constraint while a rowset is opened on the table => DB_E_TABLEINUSE
int Variation_21();
// @cmember *pTableID is DB_NULLID => DB_E_BADTABLEID
int Variation_22();
// @cmember Invalid DBKIND in pTableID => DB_E_BADTABLEID
int Variation_23();
// @cmember Try to drop a check constraint while a rowset is opened on the table => DB_E_TABLEINUSE
int Variation_24();
// @cmember Try to drop a pk constraint while a rowset is opened on the table => DB_E_TABLEINUSE
int Variation_25();
// @cmember Try to drop a fk constraint while a rowset is opened on the table => DB_E_TABLEINUSE
int Variation_26();
// @cmember Both pTableID and pConstraintID are NULL => E_INVALIDARG
int Variation_27();
// @cmember Abort retain
int Variation_28();
// @cmember Abort non retain
int Variation_29();
// @cmember Commit retain
int Variation_30();
// @cmember Commit non retain
int Variation_31();
// }} TCW_TESTVARS_END
} ;
// {{ TCW_TESTCASE(TCDropConstraint)
#define THE_CLASS TCDropConstraint
BEG_TEST_CASE(TCDropConstraint, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::DropConstraint")
TEST_VARIATION(1, L"pTableID is NULL => E_INVALIDARG")
TEST_VARIATION(2, L"pTableID.uName.pwszName is NULL => DB_E_BADTABLEID")
TEST_VARIATION(3, L"Table name is empty => DB_E_BADTABLEID")
TEST_VARIATION(4, L"Table name is not the one on which the column was created")
TEST_VARIATION(5, L"Inexistent table name => DB_E_NOTABLE")
TEST_VARIATION(6, L"Maximum table name => S_OK")
TEST_VARIATION(7, L"Invalid characters in table's name => DB_E_BADTABLEID")
TEST_VARIATION(8, L"pConstraintID is NUL => E_INVALIDARG")
TEST_VARIATION(9, L"*pConstraintID is DB_NULLID => DB_E_NOCONSTRAINT")
TEST_VARIATION(10, L"Invalid DBKIND in the constraint name => DB_E_NOCONSTRAINT")
TEST_VARIATION(11, L"NULL constraint name => DB_E_NOCONSTRAINT")
TEST_VARIATION(12, L"Constraint name is empty string => DB_E_NOCONSTRAINT")
TEST_VARIATION(13, L"Inexistent constraint name => DB_E_NOCONSTRAINT")
TEST_VARIATION(14, L"Drop a constraint twice")
TEST_VARIATION(15, L"Drop a unique constraint")
TEST_VARIATION(16, L"Drop a primary key constraint")
TEST_VARIATION(17, L"Drop a foreign key constraint")
TEST_VARIATION(18, L"Drop a check constraint")
TEST_VARIATION(19, L"Create several constraints, drop a single constraint")
TEST_VARIATION(20, L"Drop a unique constraint in the referenced table, after the foreign key constraint was added")
TEST_VARIATION(21, L"Try to drop a unique constraint while a rowset is opened on the table => DB_E_TABLEINUSE")
TEST_VARIATION(22, L"*pTableID is DB_NULLID => DB_E_BADTABLEID")
TEST_VARIATION(23, L"Invalid DBKIND in pTableID => DB_E_BADTABLEID")
TEST_VARIATION(24, L"Try to drop a check constraint while a rowset is opened on the table => DB_E_TABLEINUSE")
TEST_VARIATION(25, L"Try to drop a pk constraint while a rowset is opened on the table => DB_E_TABLEINUSE")
TEST_VARIATION(26, L"Try to drop a fk constraint while a rowset is opened on the table => DB_E_TABLEINUSE")
TEST_VARIATION(27, L"Both pTableID and pConstraintID are NULL => E_INVALIDARG")
TEST_VARIATION(28, L"Abort retain")
TEST_VARIATION(29, L"Abort non retain")
TEST_VARIATION(30, L"Commit retain")
TEST_VARIATION(31, L"Commit non retain")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCAddConstraint_Multithreading)
//*-----------------------------------------------------------------------
// @class Testcase for ITableDefinitionWithConstraints::AddConstraint used in multithreaded calls
//
class TCAddConstraint_Multithreading : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
DBID **m_prgTableID;
DBCONSTRAINTDESC *m_rgConstraintDesc;
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCAddConstraint_Multithreading,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Each thread creates a different constraint
int Variation_1();
// @cmember Some of the threads try to create the same constraint name
int Variation_2();
// @cmember Unique constraints with disjoint columns
int Variation_3();
// @cmember Unique constraints with overlapping columns
int Variation_4();
// @cmember All constraint IDs are generated by the provider
int Variation_5();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
} ;
// {{ TCW_TESTCASE(TCAddConstraint_Multithreading)
#define THE_CLASS TCAddConstraint_Multithreading
BEG_TEST_CASE(TCAddConstraint_Multithreading, TCITableDefinition, L"Testcase for ITableDefinitionWithConstraints::AddConstraint used in multithreaded calls")
TEST_VARIATION(1, L"Each thread creates a different constraint")
TEST_VARIATION(2, L"Some of the threads try to create the same constraint name")
TEST_VARIATION(3, L"Unique constraints with disjoint columns")
TEST_VARIATION(4, L"Unique constraints with overlapping columns")
TEST_VARIATION(5, L"All constraint IDs are generated by the provider")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCDropConstraint_Multithreading)
//*-----------------------------------------------------------------------
// @class Multithreading test case for ITableDefinitionWithConstraints::DropConstraints
//
class TCDropConstraint_Multithreading : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
DBID **m_prgTableID;
DBID **m_prgConstraintID;
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCDropConstraint_Multithreading,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Each thread drops a different constraint => all S_OK
int Variation_1();
// @cmember Some threads try to drop the same constraint => S_OK and DB_E_NOCONSTRAINT
int Variation_2();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
} ;
// {{ TCW_TESTCASE(TCDropConstraint_Multithreading)
#define THE_CLASS TCDropConstraint_Multithreading
BEG_TEST_CASE(TCDropConstraint_Multithreading, TCITableDefinition, L"Multithreading test case for ITableDefinitionWithConstraints::DropConstraints")
TEST_VARIATION(1, L"Each thread drops a different constraint => all S_OK")
TEST_VARIATION(2, L"Some threads try to drop the same constraint => S_OK and DB_E_NOCONSTRAINT")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// {{ TCW_TEST_CASE_MAP(TCCreateTableWithConstraints_Multithreading)
//*-----------------------------------------------------------------------
// @class Multithreading test case for ITableDefinitionWithConstraints::CreateTableWithConstraints
//
class TCCreateTableWithConstraints_Multithreading : public TCITableDefinition {
private:
// @cmember Static array of variations
DECLARE_TEST_CASE_DATA();
CCTWCThreadParam *m_rgThreadParams;
public:
// {{ TCW_DECLARE_FUNCS
// @cmember Execution Routine
DECLARE_TEST_CASE_FUNCS(TCCreateTableWithConstraints_Multithreading,TCITableDefinition);
// }} TCW_DECLARE_FUNCS_END
// @cmember Initialization Routine
virtual BOOL Init();
// @cmember Termination Routine
virtual BOOL Terminate();
// {{ TCW_TESTVARS()
// @cmember Each thread builds different table => all S_OK
int Variation_1();
// @cmember Some threads build the same table => S_OK and DB_E_DUPLICATETABLEID
int Variation_2();
// }} TCW_TESTVARS_END
unsigned MyThreadProc(ULONG i);
} ;
// {{ TCW_TESTCASE(TCCreateTableWithConstraints_Multithreading)
#define THE_CLASS TCCreateTableWithConstraints_Multithreading
BEG_TEST_CASE(TCCreateTableWithConstraints_Multithreading, TCITableDefinition, L"Multithreading test case for ITableDefinitionWithConstraints::CreateTableWithConstraints")
TEST_VARIATION(1, L"Each thread builds different table => all S_OK")
TEST_VARIATION(2, L"Some threads build the same table => S_OK and DB_E_DUPLICATETABLEID")
END_TEST_CASE()
#undef THE_CLASS
// }} TCW_TESTCASE_END
// }} TCW_TEST_CASE_MAP_END
// }} END_DECLARE_TEST_CASES()
// {{ TCW_TESTMODULE(ThisModule)
TEST_MODULE(18, ThisModule, gwszModuleDescrip)
TEST_CASE(1, TCAddColumn)
TEST_CASE(2, TCDropColumn)
TEST_CASE(3, TCDropTable)
TEST_CASE(4, TCCreateTable)
TEST_CASE(5, RODataSource)
TEST_CASE(6, TCAddConstraint_Boundary)
TEST_CASE(7, TCAddConstraint_UNIQUE)
TEST_CASE(8, TCAddConstraint_PRIMARYKEY)
TEST_CASE(9, TCAddConstraint_FOREIGNKEY)
TEST_CASE(10, TCAddConstraint_CHECK)
TEST_CASE(11, TCAddConstraint_Deferrability)
TEST_CASE(12, TCCreateTableWithConstraints_NoConstraint)
TEST_CASE(13, TCCreateTableWithConstraints)
TEST_CASE(14, TCCreateTableWithConstraints_Boundary)
TEST_CASE(15, TCDropConstraint)
TEST_CASE(16, TCAddConstraint_Multithreading)
TEST_CASE(17, TCDropConstraint_Multithreading)
TEST_CASE(18, TCCreateTableWithConstraints_Multithreading)
END_TEST_MODULE()
// }} TCW_TESTMODULE_END
class CTransactionAdapter {
public:
CTransactionAdapter() {}
~CTransactionAdapter() {}
virtual BOOL BeforeTransaction() = 0;
virtual HRESULT InsideTransactionScope() = 0;
virtual HRESULT InsideTransactionOnDDLLock() = 0;
virtual BOOL CheckCompletion() = 0;
virtual BOOL CheckRollBack() = 0;
}; //class CTransactionAdapter
class CAddConstraintTxnAdapter: public CTransactionAdapter {
protected:
TCITableDefinition *m_pTCITableDefinition;
CTable m_Table;
CConstraints *m_pConstraints;
CConsDesc *m_pCons;
// m_TransactedTable will be created inside the transaction
CTable m_TransactedTable;
// constraint on transacted table
CConsDesc *m_pTransactedTableCons;
CConstraints *m_pTxnConstraints;
public:
CAddConstraintTxnAdapter(TCITableDefinition *pTCITableDefinition) :
CTransactionAdapter(),
m_pTCITableDefinition(pTCITableDefinition),
m_pConstraints(NULL), m_pCons(NULL),
m_Table(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_TransactedTable(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_pTransactedTableCons(NULL),
m_pTxnConstraints(NULL)
{}
~CAddConstraintTxnAdapter() {
m_Table.DropTable();
m_TransactedTable.DropTable();
delete m_pConstraints;
delete m_pCons;
delete m_pTransactedTableCons;
delete m_pTxnConstraints;
}
TCITableDefinition *pTCITableDefinition() {return m_pTCITableDefinition;}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope() {
return m_pTCITableDefinition->AddConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_Table.GetTableID(), *m_pCons);
}
virtual HRESULT InsideTransactionOnDDLLock() {
return m_pTCITableDefinition->pITDWC()->AddConstraint(
&m_Table.GetTableID(), *m_pCons);
}
virtual BOOL CheckCompletion() {
TBEGIN
BOOL fTableExisted;
ASSERT(m_pCons);
CHECK(m_pConstraints->CheckAddConstraints(1, *m_pCons), S_OK);
// transacted table exists
ASSERT(m_pTransactedTableCons);
CHECK(m_TransactedTable.DoesTableExist(&m_TransactedTable.GetTableID(), &fTableExisted), S_OK);
COMPARE(fTableExisted, TRUE);
CHECK(m_pTxnConstraints->CheckAddConstraints(1, *m_pTransactedTableCons), S_OK);
TRETURN
}
virtual BOOL CheckRollBack() {
TBEGIN
BOOL fTableExisted;
ASSERT(m_pCons);
CHECK(m_pConstraints->AreConstraintsPreserved(), S_OK);
// transacted table does not exist
ASSERT(m_pTransactedTableCons);
CHECK(m_TransactedTable.DoesTableExist(&m_TransactedTable.GetTableID(), &fTableExisted), S_OK);
COMPARE(fTableExisted, FALSE);
CHECK(m_pTxnConstraints->AreConstraintsPreserved(), S_OK);
TRETURN
}
}; //class CAddConstraintTxnAdapter
class CAddUniqueConsTxnAdapter: public CAddConstraintTxnAdapter {
public:
CAddUniqueConsTxnAdapter(TCITableDefinition *pTCITableDefinition):
CAddConstraintTxnAdapter(pTCITableDefinition) {}
~CAddUniqueConsTxnAdapter() {
}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope();
virtual HRESULT InsideTransactionOnDDLLock();
virtual BOOL CheckCompletion();
virtual BOOL CheckRollBack();
}; //class CAddUniqueConsTxnAdapter
class CAddPrimaryKeyConsTxnAdapter: public CAddUniqueConsTxnAdapter {
public:
CAddPrimaryKeyConsTxnAdapter(TCITableDefinition *pTCITableDefinition):
CAddUniqueConsTxnAdapter(pTCITableDefinition)
{}
~CAddPrimaryKeyConsTxnAdapter() {
}
virtual BOOL BeforeTransaction();
}; //class CAddPrimaryKeyConsTxnAdapter
class CAddFKConsTxnAdapter: public CAddConstraintTxnAdapter {
private:
CTable m_ReferencedTable;
public:
CAddFKConsTxnAdapter(TCITableDefinition *pTCITableDefinition):
CAddConstraintTxnAdapter(pTCITableDefinition),
m_ReferencedTable(g_pIOpenRowset, (LPWSTR)gwszModuleName)
{}
~CAddFKConsTxnAdapter() {
m_Table.DropTable();
m_TransactedTable.DropTable();
m_ReferencedTable.DropTable();
}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope();
virtual HRESULT InsideTransactionOnDDLLock();
virtual BOOL CheckCompletion();
virtual BOOL CheckRollBack();
}; //class CAddFKConsTxnAdapter
class CAddCheckConsTxnAdapter: public CAddConstraintTxnAdapter {
public:
CAddCheckConsTxnAdapter(TCITableDefinition *pTCITableDefinition):
CAddConstraintTxnAdapter(pTCITableDefinition)
{}
~CAddCheckConsTxnAdapter() {}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope();
virtual HRESULT InsideTransactionOnDDLLock();
virtual BOOL CheckCompletion();
virtual BOOL CheckRollBack();
}; //class CAddCheckConsTxnAdapter
class CCreateTableWithConsTxnAdapter: public CTransactionAdapter {
protected:
TCITableDefinition *m_pTCITableDefinition;
CTable m_Table;
CConstraints *m_pConstraints;
CConsDescArray m_ConsDescArray;
// m_TransactedTable will be created inside the transaction
CTable m_RefTable;
DBORDINAL m_cColumnDesc;
DBCOLUMNDESC *m_rgColumnDesc;
public:
CCreateTableWithConsTxnAdapter(TCITableDefinition *pTCITableDefinition) :
CTransactionAdapter(),
m_pTCITableDefinition(pTCITableDefinition),
m_pConstraints(NULL),
m_Table(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_RefTable(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_cColumnDesc(0), m_rgColumnDesc(NULL)
{}
~CCreateTableWithConsTxnAdapter() {
m_Table.DropTable();
m_RefTable.DropTable();
delete m_pConstraints;
m_pConstraints = NULL;
ReleaseColumnDesc(m_rgColumnDesc, m_cColumnDesc);
}
TCITableDefinition *pTCITableDefinition() {return m_pTCITableDefinition;}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope() {
return m_pTCITableDefinition->CreateAndCheckTableWithConstraints(
m_pTCITableDefinition->pITDWC(),
NULL,
&m_Table.GetTableID(),
m_cColumnDesc,
m_rgColumnDesc,
m_ConsDescArray,
m_ConsDescArray,
IID_NULL,
0, NULL,
NULL,
NULL);
}
virtual HRESULT InsideTransactionOnDDLLock() {
return m_pTCITableDefinition->pITDWC()->CreateTableWithConstraints(
NULL, &m_Table.GetTableID(),
m_cColumnDesc,
m_rgColumnDesc,
m_ConsDescArray,
m_ConsDescArray,
IID_NULL,
0, NULL,
NULL,
NULL);
}
virtual BOOL CheckCompletion() {
TBEGIN
BOOL fTableExisted;
// check constraints were added
CHECK(m_pConstraints->CheckAddConstraints(m_ConsDescArray, m_ConsDescArray), S_OK);
// transacted table exists
CHECK(m_Table.DoesTableExist(&m_Table.GetTableID(), &fTableExisted), S_OK);
COMPARE(fTableExisted, TRUE);
TRETURN
}
virtual BOOL CheckRollBack() {
TBEGIN
BOOL fTableExisted;
CHECK(m_pConstraints->AreConstraintsPreserved(), S_OK);
// transacted table does not exist
CHECK(m_Table.DoesTableExist(&m_Table.GetTableID(), &fTableExisted), S_OK);
COMPARE(fTableExisted, FALSE);
TRETURN
}
}; //class CCreateTableWithConsTxnAdapter
class CDropConsTxnAdapter: public CTransactionAdapter {
protected:
TCITableDefinition *m_pTCITableDefinition;
CTable m_Table;
CTable m_RefTable;
CConstraints *m_pConstraints;
CPrimaryKeyCons *m_pPKCons;
CForeignKeyCons *m_pFKCons;
CUniqueCons *m_pUniqueCons;
CCheckCons *m_pCheckCons;
public:
CDropConsTxnAdapter(TCITableDefinition *pTCITableDefinition) :
CTransactionAdapter(),
m_pTCITableDefinition(pTCITableDefinition),
m_pConstraints(NULL),
m_Table(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_RefTable(g_pIOpenRowset, (LPWSTR)gwszModuleName),
m_pPKCons(NULL), m_pFKCons(NULL), m_pUniqueCons(NULL), m_pCheckCons(NULL)
{}
~CDropConsTxnAdapter() {
m_Table.DropTable();
m_RefTable.DropTable();
delete m_pConstraints;
delete m_pPKCons;
delete m_pFKCons;
delete m_pUniqueCons;
delete m_pCheckCons;
}
TCITableDefinition *pTCITableDefinition() {return m_pTCITableDefinition;}
virtual BOOL BeforeTransaction();
virtual HRESULT InsideTransactionScope() {
HRESULT hr = S_OK;
HRESULT hres;
hres = m_pTCITableDefinition->DropConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_Table.GetTableID(), *m_pPKCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->DropConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_Table.GetTableID(), *m_pFKCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->DropConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_Table.GetTableID(), *m_pUniqueCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->DropConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_Table.GetTableID(), *m_pCheckCons);
hr = (S_OK == hr)? hres: hr;
return hr;
}
virtual HRESULT InsideTransactionOnDDLLock() {
HRESULT hr = S_OK;
HRESULT hres;
hres = m_pTCITableDefinition->pITDWC()->DropConstraint(
&m_Table.GetTableID(), *m_pPKCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->pITDWC()->DropConstraint(
&m_Table.GetTableID(), *m_pFKCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->pITDWC()->DropConstraint(
&m_Table.GetTableID(), *m_pUniqueCons);
hr = (S_OK == hr)? hres: hr;
hres = m_pTCITableDefinition->pITDWC()->DropConstraint(
&m_Table.GetTableID(), *m_pCheckCons);
hr = (S_OK == hr)? hres: hr;
return hr;
}
virtual BOOL CheckCompletion() {
TBEGIN
ASSERT(m_pPKCons);
ASSERT(m_pFKCons);
ASSERT(m_pUniqueCons);
ASSERT(m_pCheckCons);
CHECK(m_pConstraints->CheckDropConstraint(*m_pPKCons), S_OK);
CHECK(m_pConstraints->CheckDropConstraint(*m_pFKCons), S_OK);
CHECK(m_pConstraints->CheckDropConstraint(*m_pUniqueCons), S_OK);
CHECK(m_pConstraints->CheckDropConstraint(*m_pCheckCons), S_OK);
TRETURN
}
virtual BOOL CheckRollBack() {
TBEGIN
ASSERT(m_pPKCons);
ASSERT(m_pFKCons);
ASSERT(m_pUniqueCons);
ASSERT(m_pCheckCons);
CHECK(m_pConstraints->AreConstraintsPreserved(), S_OK);
TRETURN
}
}; //class CDropConsTxnAdapter
class CTransactionLocal {
protected:
CLightDataSource m_DataSource;
CLightSession m_Session;
LONG m_lSupportedTxnDDL;
CTransactionAdapter *m_pTAdapter;
public:
CTransactionLocal(
) {
m_pTAdapter = NULL;
m_lSupportedTxnDDL = DBPROPVAL_TC_NONE;
}
~CTransactionLocal() { }
virtual HRESULT StartTransaction(
IUnknown *pISessionUnknown,
// arguments for ITransactionLocal::StartTransaction
ISOLEVEL isoLevel,
ULONG isoFlags,
ITransactionOptions *pOtherOptions
);
virtual HRESULT Abort(
BOID * pboidReason,
BOOL fRetaining,
BOOL fAsync
) {
return ((ITransactionLocal*)m_Session)->Abort(pboidReason, fRetaining, fAsync);
}
virtual HRESULT Commit(
BOOL fRetaining,
DWORD grfTC,
DWORD grfRM
) {
return ((ITransactionLocal*)m_Session)->Commit(fRetaining, grfTC, grfRM);
}
virtual BOOL DoTransactionTest(
IUnknown *pISessionUnknown,
CTransactionAdapter *pTAdapter,
// arguments for ITransactionLocal::Abort / Commit
BOOL fDDL, // whether or not this is a DDL call
BOOL fAbortCommit, // whether to abort or commit
BOOL fRetaining // if it's retaining or not
);
}; //CTransactionLocal
//---------------------------------------------------------------------
//
// @cmember Initialize the TCIDefinition data members
//---------------------------------------------------------------------
BOOL TCITableDefinition::Init()
{
m_pITDWC = NULL;
m_pITableDefinition = NULL;
m_nTables = 0;
InitializeCriticalSection(&m_CriticalSection);
if(CSessionObject::Init())
{
SetDataSourceObject(m_pThisTestModule->m_pIUnknown);
SetDBSession(m_pThisTestModule->m_pIUnknown2);
// select ITableDefinition as standard table creation method
GetModInfo()->UseITableDefinition(TRUE);
GetProviderTypes();
GetLiteralInfo();
m_nTables = GetNoOfTables();
m_pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// check for ITableDefinition
if (!(m_hr=VerifyInterface(m_pIOpenRowset, IID_ITableDefinition, SESSION_INTERFACE, (IUnknown**)&m_pITableDefinition)))
return FALSE;
m_pIOpenRowset->QueryInterface(IID_ITableDefinitionWithConstraints, (void**)&m_pITDWC);
if (m_pITDWC)
{
// find out what values of matching types are supported for foreign keys
DBORDINAL rgCol[] = {1};
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable Table2(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
HRESULT hr;
TESTC_(Table.CreateTable(0, 1), S_OK);
CHECK(Table.AddInfoFromColumnsSchemaRowset(m_pITableDefinition), S_OK);
TESTC_(Table2.CreateTable(0, 1), S_OK);
CHECK(Table2.AddInfoFromColumnsSchemaRowset(m_pITableDefinition), S_OK);
m_SupportedMatchType = DBMATCHTYPE_NONE;
TEST2C_(hr = AddForeignKeyConstraint(&Table, NUMELEM(rgCol), rgCol, &Table2, NUMELEM(rgCol), rgCol,
m_SupportedMatchType), S_OK, DB_E_BADMATCHTYPE);
if (S_OK != hr)
{
m_SupportedMatchType = DBMATCHTYPE_PARTIAL;
TEST2C_(hr = AddForeignKeyConstraint(&Table, NUMELEM(rgCol), rgCol, &Table2, NUMELEM(rgCol), rgCol,
m_SupportedMatchType), S_OK, DB_E_BADMATCHTYPE);
if (S_OK != hr)
{
m_SupportedMatchType = DBMATCHTYPE_FULL;
TESTC_(hr = AddForeignKeyConstraint(&Table, NUMELEM(rgCol), rgCol, &Table2, NUMELEM(rgCol), rgCol,
m_SupportedMatchType), S_OK);
}
}
CLEANUP:
Table.DropTable();
Table2.DropTable();
}
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------
//
// @cmember constructor
//---------------------------------------------------------------------
TCITableDefinition::TCITableDefinition(WCHAR *wstrTestCaseName):CSessionObject(wstrTestCaseName)
{
m_fIsIDBInfo = NULL;
m_pwszInvalidTableChars = NULL;
m_pwszInvalidColChars = NULL;
m_pITableDefinition = NULL;
m_rgColumnDesc = NULL;
m_cColumnDesc = 0;
} //TCITableDefinition::TCITableDefinition
//-------------------------------------------------------------------------
//
// @cmember Compare two column in the identical position
//-------------------------------------------------------------------------
BOOL TCITableDefinition::AreColEqual
(
DBCOLUMNDESC *oldCD,
DBCOLUMNDESC *newCD
)
{
// when this function is called, it is supposed that m_HasAuto... were set by GetTableColumnInfo
// and unmodified ever since
ULONG cPropSet, cProp;
BOOL fResult = FALSE;
DBPROPSET *pNewPropSet = NULL;
DBPROPSET *pOldPropSet = NULL;
DBPROP *pNewProp = NULL;
DBPROP *pOldProp = NULL;
// compare everything in the stru
ASSERT(oldCD->pTypeInfo == newCD->pTypeInfo);
TESTC(oldCD->pTypeInfo == newCD->pTypeInfo);
TESTC(oldCD->ulColumnSize == newCD->ulColumnSize);
TESTC(oldCD->wType == newCD->wType);
TESTC(!IsNumericType(oldCD->wType) || oldCD->bPrecision == newCD->bPrecision);
TESTC( (oldCD->wType != DBTYPE_NUMERIC && oldCD->wType != DBTYPE_DECIMAL)
|| oldCD->bScale == newCD->bScale);
TESTC(m_hr = CompareDBID(oldCD->dbcid, newCD->dbcid, m_pIDBInitialize));
// invalidated for the time being
// if the CLSID are to be compared for the lists, then a GUID object has to be allocated and mentained;
// during the life of each ColumnDescriptor array
// if a pointer to m_gTypeGUID of a column is stored we'll have troubles as soon as the value of the column changes
//if (m_pTable->GetHasCLSID() && !CHECK(oldCD->pclsid == newCD->pclsid, TRUE))
// return FALSE;
// compare the properties
TESTC(oldCD->cPropertySets == newCD->cPropertySets);
for (cPropSet=0; cPropSet<oldCD->cPropertySets; cPropSet++)
{
pOldPropSet = &(oldCD->rgPropertySets[cPropSet]);
pNewPropSet = &(newCD->rgPropertySets[cPropSet]);
// compare the props in that prop set
TESTC(pOldPropSet->guidPropertySet == pNewPropSet->guidPropertySet);
TESTC(pOldPropSet->cProperties == pNewPropSet->cProperties);
for (cProp = 0; cProp < pOldPropSet->cProperties; cProp++)
{
pOldProp = &(pOldPropSet->rgProperties[cProp]);
pNewProp = &(pNewPropSet->rgProperties[cProp]);
// there are no info for some of the properties
if ( ((pNewProp->dwPropertyID == DBPROP_COL_AUTOINCREMENT) && !m_pTable->GetHasAuto())
|| ((pNewProp->dwPropertyID == DBPROP_COL_DEFAULT) && !m_pTable->GetHasDefault())
|| ((pNewProp->dwPropertyID == DBPROP_COL_UNIQUE) && !m_pTable->GetHasUnique())
)
continue;
TESTC(pOldProp->dwPropertyID == pNewProp->dwPropertyID);
TESTC(CompareVariant(&(pOldProp->vValue), &(pNewProp->vValue)));
}
}
fResult = TRUE;
CLEANUP:
return fResult;
} //TCITableDefinition::AreColEqual
//-------------------------------------------------------------------------
//
// @cmember Compare the list of old columns against the list of new columns
//-------------------------------------------------------------------------
BOOL TCITableDefinition::AreColEqual
(
DBCOLUMNDESC *oldCD,
DBORDINAL oldlen,
DBCOLUMNDESC *newCD,
DBORDINAL newlen
)
{
// when this function is called, it is supposed that m_HasAuto... were set by GetTableColumnInfo
// and unmodified ever since
ULONG i;
BOOL fResult = FALSE;
TESTC(oldlen == newlen);
for (i=0; i<oldlen; i++)
{
TESTC(AreColEqual(&newCD[i], &oldCD[i]));
}
fResult = TRUE;
CLEANUP:
return fResult;
} //TCITableDefinition::AreColEqual
//--------------------------------------------------------------------------
//
// @cmember Check the result and property status
//--------------------------------------------------------------------------
BOOL TCITableDefinition::CheckPropertyStatus(
GUID guidPropertySet, // [in] property set guid
GUID guidExpectedPS, // [in] expected prop set guid
DBPROP *pProp , // [in] property
HRESULT hr // [in] the result
)
{
BOOL fRes = TRUE;
BOOL fSupported;
BOOL fSettable;
VARTYPE vtType;
if (!pProp)
return TRUE;
// general checking
if (DBPROPOPTIONS_REQUIRED == pProp->dwOptions && DBPROPSTATUS_OK != pProp->dwStatus)
fRes = COMPARE(FAILED(hr), TRUE);
if (!(guidPropertySet == guidExpectedPS) )
// check a couple of things and returns
return COMPARE(pProp->dwStatus, DBPROPSTATUS_NOTSUPPORTED) && COMPARE(S_OK != hr, TRUE);
fSupported = SupportedProperty(pProp->dwPropertyID, guidPropertySet);
fSettable = SettableProperty(pProp->dwPropertyID, guidPropertySet);
if (!fSupported && !COMPARE(S_OK != hr, TRUE))
fRes = FALSE;
// status driven checking
switch (pProp->dwStatus)
{
case DBPROPSTATUS_OK:
fRes = COMPARE(fSupported != 0, TRUE);
break;
case DBPROPSTATUS_NOTSUPPORTED:
fRes = COMPARE(fSupported == 0, TRUE);
break;
case DBPROPSTATUS_NOTSETTABLE:
fRes = COMPARE(fSupported != 0, TRUE) && CHECK(fSettable == 0, TRUE);
break;
case DBPROPSTATUS_BADOPTION:
fRes = (pProp->dwOptions != DBPROPOPTIONS_OPTIONAL)
&& COMPARE(DBPROPOPTIONS_REQUIRED != pProp->dwOptions, TRUE);
break;
case DBPROPSTATUS_CONFLICTING:
fRes = COMPARE(fSettable != 0, TRUE);
break;
case DBPROPSTATUS_BADVALUE:
// this could mean not supported property or value
break;
}
// DBPROPSTATUS_BADVALUE can be certainly got only if type of the prop is wrong
// info about supported discret values of the prop cannot be generacally obtained
// before creating an index
vtType = GetPropInfoType(pProp->dwPropertyID, guidPropertySet);
if ( DBPROP_COL_DEFAULT != pProp->dwPropertyID
&& vtType != pProp->vValue.vt
&& !COMPARE(DBPROPSTATUS_OK == pProp->dwStatus, FALSE))
{
odtLog << "ERROR: bad propstatus on improper type value on property" << pProp->dwPropertyID << "\n";
fRes = FALSE;
}
return fRes;
} //TCITableDefinition::CheckProperty
//--------------------------------------------------------------------
//
// @cmember Check the prop status of a list of col desc
// returns TRUE if all status are set consistent with prop and result
// FALSE otherwise
//--------------------------------------------------------------------
BOOL TCITableDefinition::CheckColPropStatus(
DBORDINAL cColDesc, // [in]
DBCOLUMNDESC *rgColDesc, // [in] the size of the propset array
HRESULT hr // [in] the result of the previous op
)
{
ULONG cPropSet;
ULONG cProp;
BOOL fRes = TRUE;
DBORDINAL nCol;
if (!rgColDesc)
return TRUE;
for (nCol = 0; nCol < cColDesc; nCol++)
{
if (!rgColDesc[nCol].rgPropertySets)
continue;
for (cPropSet = 0; cPropSet < rgColDesc[nCol].cPropertySets; cPropSet++)
{
if (!rgColDesc[nCol].rgPropertySets[cPropSet].rgProperties)
continue;
for (cProp = 0; cProp < rgColDesc[nCol].rgPropertySets[cPropSet].cProperties; cProp++)
{
fRes = fRes && CheckPropertyStatus(rgColDesc[nCol].rgPropertySets[cPropSet].guidPropertySet,
DBPROPSET_COLUMN, &rgColDesc[nCol].rgPropertySets[cPropSet].rgProperties[cProp], hr);
}
}
}
return fRes;
} // TCITableDefinition::CheckColPropStatus
//--------------------------------------------------------------------
//
// @cmember CompareColumnDesc
// pColumnDesc and pNewCol [IN] parameteres to be compared
// column addition (table creation) is assumed to have succeeded
// returns TRUE or FALSE
//--------------------------------------------------------------------
BOOL TCITableDefinition::CompareColumnDesc(
DBCOLUMNDESC *pColumnDesc, // [in] column descriptor, as passed to ITableDefinition::AddColumn()
DBCOLUMNDESC *pNewCol // [in] column descriptor, as read from the table after addition
)
{
DBPROPSET *pNewPropSet = NULL;
DBPROPSET *pInPropSet = NULL;
DBPROP *pInProp = NULL;
ULONG j;
ULONG cPropSet, cProp;
ULONG n;
POSITION pos, posOld, posFind;
CCol col;
BOOL fRes = FALSE;
GUID gCD;
TESTC(pColumnDesc->pTypeInfo == pNewCol->pTypeInfo);
PRVTRACE("TCITableDefinition::CompareColumnDesc: pColumnDesc->wType = %d, pNewCol->wType = %d\n",
pColumnDesc->wType, pNewCol->wType);
TESTC(pColumnDesc->wType == pNewCol->wType);
TESTC(CompareDBID(pColumnDesc->dbcid, pNewCol->dbcid, m_pIDBInitialize));
// if there is a provider type name, the column size, precision and
// scale of the column can be checked otherwise skip it there could
// be several provider types implemented on the DBTYPE
if (!pColumnDesc->pwszTypeName)
{
// are multiple provider types implemented on the same DBTYPE?
for (posFind = pos = m_ColList.GetHeadPosition(), n=0; pos;)
{
posOld = pos;
col = m_ColList.GetNext(pos);
if (col.GetProviderType() == pNewCol->wType)
{
n++;
posFind = posOld;
}
}
col = m_ColList.GetAt(posFind);
}
else
{
BOOL fExistType;
col = GetType(GetColumnTypeName(pColumnDesc), pNewCol->wType, &fExistType);
n = fExistType ? 1: 0;
}
// see if there are enough data for a compColumnDescrison
if (1 != n)
{
fRes = TRUE;
goto CLEANUP;
}
// CHECK THE COLUMN SIZE
// for DBTYPE_STR, DBTYPE_WSTR, DBTYPE_BSTR check whether the
// size of the column fits with the spec ones or the maximum
if ((pNewCol->wType == DBTYPE_STR) ||
(pNewCol->wType == DBTYPE_WSTR) ||
(pNewCol->wType == DBTYPE_BYTES) )
{
LPWSTR pwszCreateParams = col.GetCreateParams();
if (col.GetColumnSize() >= pColumnDesc->ulColumnSize)
{
if ( 0 != pColumnDesc->ulColumnSize
&& pwszCreateParams
&& NULL != wcsstr(pwszCreateParams, L"length"))
TESTC(pColumnDesc->ulColumnSize == pNewCol->ulColumnSize);
}
else
{
// Check for varchar(max), nvarchar(max), and varbinary(max) types
if ((pColumnDesc->pwszTypeName &&
(wcscmp(pColumnDesc->pwszTypeName, L"varchar") == 0 ||
wcscmp(pColumnDesc->pwszTypeName, L"nvarchar") == 0 ||
wcscmp(pColumnDesc->pwszTypeName, L"varbinary") == 0))
||
(pNewCol->wType == DBTYPE_WSTR || pNewCol->wType == DBTYPE_BYTES)
)
{
//Note: we need to verify column size as read from the table after column addition (pNewCol),
TESTC(pNewCol->ulColumnSize == ~(DBLENGTH)0);
}
else
// column size should be set to the max column size allowed
TESTC(col.GetColumnSize() == pNewCol->ulColumnSize);
}
}
else
if (!IsFixedLength(pNewCol->wType) && DBTYPE_VARNUMERIC != pNewCol->wType)
TESTC(pNewCol->ulColumnSize == (DBLENGTH)~0);
// CHECK THE PRECISION
if (IsNumericType(pColumnDesc->wType) || DBTYPE_DBTIMESTAMP == pColumnDesc->wType)
{
if (0 < pColumnDesc->bPrecision)
if ( DBTYPE_NUMERIC == pColumnDesc->wType
|| DBTYPE_VARNUMERIC == pColumnDesc->wType )
{
if (DBTYPE_VARNUMERIC != pColumnDesc->wType ) //
TESTC(pColumnDesc->bPrecision == pNewCol->bPrecision);
}
else
TESTC(col.GetPrecision() == pNewCol->bPrecision);
}
else
TESTC(pNewCol->bPrecision == (BYTE)~0);
// CHECK SCALE
if ( DBTYPE_NUMERIC == pColumnDesc->wType
|| DBTYPE_VARNUMERIC == pColumnDesc->wType
|| DBTYPE_DECIMAL == pColumnDesc->wType
|| DBTYPE_DBTIMESTAMP == pColumnDesc->wType)
{
if (DBTYPE_VARNUMERIC != pColumnDesc->wType )
if ( DBTYPE_DBTIMESTAMP != pColumnDesc->wType
&& pColumnDesc->bScale >= col.GetMinScale()
&& pColumnDesc->bScale > col.GetMaxScale())
TESTC(pColumnDesc->bScale == pNewCol->bScale);
}
else
TESTC(pNewCol->bScale == (BYTE)~0); // as set trhough col.SetColInfo
// get the psid
if (pColumnDesc->pclsid)
gCD = *pColumnDesc->pclsid;
else
gCD = GUID_NULL;
TESTC(!m_pTable->GetHasCLSID() || gCD == *(GUID*)pNewCol->pclsid);
if (NULL == pColumnDesc->rgPropertySets)
{
fRes = TRUE;
goto CLEANUP;
}
for (cPropSet=0; cPropSet<(pColumnDesc->cPropertySets); cPropSet++)
{
pInPropSet = &(pColumnDesc->rgPropertySets[cPropSet]);
if ( pInPropSet->guidPropertySet != DBPROPSET_COLUMN )
{
for (cProp=0; cProp < pInPropSet->cProperties; cProp++)
TESTC(DBPROPSTATUS_NOTSUPPORTED == pInPropSet->rgProperties[cProp].dwStatus);
continue;
}
// Find matching PropSet
for(j = 0; j < pNewCol->cPropertySets &&
pNewCol->rgPropertySets[j].guidPropertySet != pInPropSet->guidPropertySet; j++);
if (j >= pNewCol->cPropertySets)
continue;
pNewPropSet = &(pNewCol->rgPropertySets[j]);
// compColumnDescre the propPropSet in the column prop set
ASSERT(pNewPropSet->rgProperties);
if (NULL == pInPropSet->rgProperties)
continue;
for (cProp=0; cProp < pInPropSet->cProperties; cProp++)
{
pInProp = &(pInPropSet->rgProperties[cProp]);
if (pInPropSet->guidPropertySet == DBPROPSET_COLUMN)
{
// look for that property inside the resulted column
if (((pInProp->dwPropertyID == DBPROP_COL_AUTOINCREMENT) && !m_pTable->GetHasAuto() ) ||
((pInProp->dwPropertyID == DBPROP_COL_DEFAULT) && !m_pTable->GetHasDefault() ) ||
((pInProp->dwPropertyID == DBPROP_COL_UNIQUE) && !m_pTable->GetHasUnique()) )
// better check the status, it should be DBPROPSTATUS_NOTSUPPORTED
continue;
TESTC( SupportedProperty(pInProp->dwPropertyID, pInPropSet->guidPropertySet)
|| DBPROPSTATUS_NOTSUPPORTED == pInProp->dwStatus);
TESTC( SettableProperty(pInProp->dwPropertyID, pInPropSet->guidPropertySet)
|| DBPROPSTATUS_NOTSUPPORTED == pInProp->dwStatus);
// identify the property
for ( j=0;
j< pNewPropSet->cProperties
&& pNewPropSet->rgProperties[j].dwPropertyID != pInProp->dwPropertyID;
j++);
if (j>=pNewPropSet->cProperties)
continue;
// try to detect the right dbpropstatus
TESTC( (DBPROPSTATUS_OK != pInProp->dwStatus)
|| CompareVariant(&pInProp->vValue, &pNewPropSet->rgProperties[j].vValue));
}
// skipping the testing of other provider-specific property sets
}
}
fRes = TRUE;
CLEANUP:
return fRes;
} //TCITableDefinition::CompColumnDescreColumnDesc
//--------------------------------------------------------------------
//
// @cmember Compare the list of old columns against the list of new columns and the new column
// the place where the newly added column was added is provider specific!
//--------------------------------------------------------------------
BOOL TCITableDefinition::CheckColInfo
(
DBCOLUMNDESC *oldCD,
DBORDINAL oldlen,
DBCOLUMNDESC *newCD,
DBORDINAL newlen,
DBCOLUMNDESC *pColumnDesc // the new column to be add
)
{
// when this function is called, it is supposed that m_HasAuto... were set by GetTableColumnInfo
// and unmodified ever since
BOOL fNewColumn = FALSE;
BOOL fResult = FALSE;
DBORDINAL cOldCol;
DBORDINAL cNewCol;
TESTC(newlen == oldlen+1);
for (cOldCol=cNewCol=0; cNewCol<newlen; cNewCol++)
{
if ( (cOldCol < oldlen)
&& CompareDBID(oldCD[cOldCol].dbcid, newCD[cNewCol].dbcid, m_pIDBInitialize))
{
TESTC(AreColEqual(&oldCD[cOldCol], &newCD[cNewCol]));
cOldCol++;
}
else
{
TESTC(!fNewColumn);
TESTC(CompareColumnDesc(pColumnDesc, &newCD[cOldCol]));
fNewColumn = TRUE;
}
}
fResult = TRUE;
CLEANUP:
return fResult;
} //TCITableDefinition::CheckColInfo
//--------------------------------------------------------------------------
//
// @cmember TCITableDefinition::CheckRowset
//--------------------------------------------------------------------------
BOOL TCITableDefinition::CheckRowset(IUnknown *pIRowset)
{
IRowsetInfo* pInterface = NULL;
BOOL hr;
if (!pIRowset)
return TRUE;
if (hr = DefaultObjectTesting(pIRowset, ROWSET_INTERFACE))
{
// just for curiosity
if (VerifyInterface( pIRowset,
IID_IRowsetInfo,
ROWSET_INTERFACE,
(IUnknown**)&pInterface))
{
IUnknown* tempInterface;
if (pInterface->GetSpecification(IID_IUnknown, &tempInterface) == S_FALSE)
{
// what if table ID doesn't specify a name?
PRVTRACE(L"** No object has created the rowset");
}
else
{
IUnknown *pIID;
if (tempInterface->QueryInterface(IID_IGetDataSource, (void**)&pIID) == S_OK)
{
PRVTRACE(L"** Rowset was created by a session");
SAFE_RELEASE(pIID);
}
else
PRVTRACE(L"** Rowset was created by a command");
SAFE_RELEASE(tempInterface);
}
SAFE_RELEASE(pInterface);
}
}
return hr;
} //CTable::CheckRowset
//--------------------------------------------------------------------------
//
// @cmember Fills in a variant with whatever it needs
//--------------------------------------------------------------------------
BOOL TCITableDefinition::FillVariant(VARIANT *pVariant)
{
BOOL fRes = FALSE;
BSTR pwszValue = L"\'some value\'";
WCHAR *pwszStrValue = L"\'value\'";
TESTC(NULL != pVariant);
switch (pVariant->vt)
{
case DBTYPE_R4:
V_R4(pVariant) = (float)3.1415926;
break;
case DBTYPE_R8:
V_R8(pVariant) = 2.71828;
break;
case DBTYPE_BSTR:
V_BSTR(pVariant) = SysAllocString(pwszValue);
break;
case DBTYPE_STR:
case DBTYPE_WSTR:
pVariant->vt = DBTYPE_BSTR;
V_BSTR(pVariant) = SysAllocString(pwszStrValue);
break;
case DBTYPE_BYTES:
V_BYREF(pVariant) = SysAllocString(pwszStrValue);
break;
}
fRes = TRUE;
CLEANUP:
return fRes;
} // TCITableDefinition::FillVariant
// @cmember Builds a default value for a given column type
BOOL TCITableDefinition::GetDefaultValue(
DBCOLUMNDESC *pColumnDesc, // [in] column descriptor
VARIANT *pVariant, // [out] pointer to the variant that stores the default value
CTable *pTable // [in] CTable to be used (default NULL)
)
{
TBEGIN
CTable *pCTable = NULL;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
CCol col;
WCHAR *pwszDefVal = NULL;
ULONG ulRowNum = 28;
HRESULT hr;
TESTC(NULL != pColumnDesc); // && NULL != pColumnDesc->pwszTypeName);
TESTC(NULL != pVariant);
VariantInit(pVariant);
if (pTable)
pCTable = pTable;
else
{
pCTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
pCTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
}
pCTable->GetColInfo(col, GetColumnTypeName(pColumnDesc));
SAFE_ALLOC(pwszDefVal, WCHAR, MAXDATALEN);
pwszDefVal[0]=L'\0';
TESTC_(hr = col.MakeData(pwszDefVal,ulRowNum,PRIMARY,NONULLS), S_OK);
pVariant->vt = DBTYPE_BSTR; //col.GetProviderType();
V_BSTR(pVariant) = SysAllocString(pwszDefVal);
SAFE_FREE(pwszDefVal);
// Use the US_English LCID first and then the System LCID
hr=VariantChangeTypeEx(pVariant, pVariant, MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT), VARIANT_NOVALUEPROP, col.GetProviderType());
if(S_OK != hr)
hr=VariantChangeTypeEx(pVariant, pVariant, GetSystemDefaultLCID(), VARIANT_NOVALUEPROP, col.GetProviderType());
if (S_OK != hr)
{
// try to set it as a VT_BSTR value
VariantClear(pVariant);
TESTC_(pCTable->GetLiteralAndValue(col, &pwszDefVal, ulRowNum, col.GetColNum(), PRIMARY), S_OK);
pVariant->vt = DBTYPE_BSTR;
V_BSTR(pVariant) = SysAllocString(pwszDefVal);
TEST2C_(hr, DISP_E_BADVARTYPE, DISP_E_TYPEMISMATCH);
}
CLEANUP:
SAFE_FREE(pwszDefVal);
if (!pTable)
delete pCTable;
TRETURN
} // TCITableDefinition::GetDefaultValue
//--------------------------------------------------------------------------
//
// @cmember Get the number of tables in a data sources, base on IDBSchemaRowset
//--------------------------------------------------------------------------
ULONG TCITableDefinition::GetNoOfTables()
{
IDBSchemaRowset *pInterface = NULL;
IRowset *pRowset = NULL;
DBCOUNTITEM n=0;
HROW * prghRows = NULL;
if (!VerifyInterface(m_pIOpenRowset,IID_IDBSchemaRowset, SESSION_INTERFACE, (IUnknown**)&pInterface))
{
PRVTRACE(L"** I could not get a pointer to IDBSchemaRowset interface");
return 0;
}
TESTC_(pInterface->GetRowset(NULL, DBSCHEMA_TABLES, 0, NULL, IID_IRowset, 0, NULL, (IUnknown**)&pRowset), S_OK);
TEST2C_(pRowset->GetNextRows(0, 0, LONG_MAX/1024, &n, &prghRows), DB_S_ENDOFROWSET, DB_S_ROWLIMITEXCEEDED );
TESTC_(pRowset->ReleaseRows(n, prghRows, NULL, NULL, NULL), S_OK)
CLEANUP:
SAFE_RELEASE(pRowset);
SAFE_RELEASE(pInterface);
PROVIDER_FREE(prghRows);
// I dont't expect the number of tables to exceed ULONG_MAX
ASSERT(n < ULONG_MAX);
return (ULONG)n;
} //TCITableDefinition::GetNoOfTables
//----------------------------------------------------------------------
//
// @cmember Drops a column and check the result against reallity
//----------------------------------------------------------------------
HRESULT TCITableDefinition::DropColumnAndCheck(
DBID *pTableID, // [in] the table ID
DBID *pColumnID, // [in] the ID of the column to be dropped
ITableDefinition *pITableDefinition,/*=NULL*/ // [in] pointer to ITableDefinition interface
DBID *pBaseTableID/*=NULL*/ // [in] if pTableID is exotic (e.g. fuly qualified) this
// table id is used to get metadata info about the table
)
{
DBCOLUMNDESC *OldColList = NULL, *NewColList = NULL;
DBORDINAL oldlen = 0, newlen = 0;
ULONG i;
LONG nCol = -1L;
HRESULT hr;
BOOL fTableExists = FALSE;
BOOL fColumnExists = FALSE;
IOpenRowset *pIOpenRowset = NULL;
IColumnsInfo *pIColumnsInfo = NULL;
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_NOCOLUMN,
DB_E_DROPRESTRICTED,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
HRESULT rgValidHResMDAC25[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_BADCOLUMNID,
DB_E_DROPRESTRICTED,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION,
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
if (!pBaseTableID)
pBaseTableID = pTableID;
if (!pITableDefinition)
pITableDefinition = m_pITableDefinition;
// check whether the table and column exist
if (pTableID)
{
TESTC(VerifyInterface(pITableDefinition, IID_IOpenRowset, SESSION_INTERFACE, (IUnknown**)&pIOpenRowset));
TEST2C_(hr = pIOpenRowset->OpenRowset(NULL, pTableID, NULL, IID_IColumnsInfo,
0, NULL, (IUnknown**)&pIColumnsInfo), S_OK, DB_E_NOTABLE);
SAFE_RELEASE(pIOpenRowset);
SAFE_RELEASE(pIColumnsInfo);
fTableExists = S_OK == hr;
}
else
fTableExists = FALSE;
// this function is based on the current table name
if (fTableExists)
{
GetColumnDescOnTable(pBaseTableID, &OldColList, &oldlen);
if (pColumnID)
{
for (fColumnExists = FALSE, i=0; !fColumnExists && (i<oldlen); i++)
{
if (CompareDBID(OldColList[i].dbcid, *pColumnID, m_pIDBInitialize))
fColumnExists = TRUE;
}
}
}
// the CHECK will be done at the caller level, where the expected return is known
if ( (hr = m_pITableDefinition->DropColumn(pTableID, pColumnID)) != S_OK)
{
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
// check that the result is one of the expected results
TESTC(CheckResult(hr, cValidHRes, g_fSQLOLEDB25 ? rgValidHResMDAC25 : rgValidHRes));
// call failed
if (fTableExists) //pTableID && pTableID->uName.pwszName)
{
GetColumnDescOnTable(pBaseTableID, &NewColList, &newlen);
TESTC(AreColEqual(NewColList, newlen, OldColList, oldlen));
if (!fColumnExists)
{
TESTC_(hr, pColumnID? (g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN): E_INVALIDARG);
}
else
{
HRESULT rgValidHRes[] = {DB_E_DROPRESTRICTED, DB_E_TABLEINUSE, DB_SEC_E_PERMISSIONDENIED, XACT_E_XTIONEXISTS, E_FAIL};
// check the possible results
TESTC(CheckResult(hr, NUMELEM(rgValidHRes), rgValidHRes));
}
}
else
{
if (pTableID)
{
TEST2C_(hr, DB_E_NOTABLE, (g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN));
}
else
TESTC_(hr, E_INVALIDARG);
}
}
else
{
// call succeeded
TESTC(fColumnExists);
GetColumnDescOnTable(pBaseTableID, &NewColList, &newlen);
for (i = 0, nCol = -1; i < oldlen && nCol < 0; i++)
{
if (CompareDBID(OldColList[i].dbcid, *pColumnID, m_pIDBInitialize))
nCol = (ULONG)i;
}
TESTC(0 <= nCol);
// this should work even when the column name is not in the original (old) table
TESTC(CheckColInfo(NewColList, newlen, OldColList, oldlen, &OldColList[nCol]));
}
CLEANUP:
SAFE_RELEASE(pIOpenRowset);
SAFE_RELEASE(pIColumnsInfo);
ReleaseColumnDesc(OldColList, oldlen);
ReleaseColumnDesc(NewColList, newlen);
return hr;
} // TCITableDefinition::DropColumnAndCheck
//--------------------------------------------------------------------------
//
// @cmember Drops a table and check the operation
//--------------------------------------------------------------------------
HRESULT TCITableDefinition::DropTableAndCheck(
DBID *pTableID, // [in] ID of the table to be dropped
ITableDefinition *pITableDefinition /*=NULL*/ // [in] pointer to ITableDefinition interface
)
{
BOOL fExists;
BOOL fTableExisted;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
HRESULT hRes;
ASSERT(pTable);
if (!pITableDefinition)
pITableDefinition = m_pITableDefinition;
// check whether the table existed before
CHECK(pTable->DoesTableExist(pTableID, &fTableExisted), S_OK);
// drop the table
hRes = pITableDefinition->DropTable(pTableID);
// check that if table was dropped it doesn't exist
TESTC(fTableExisted || !SUCCEEDED(hRes));
TESTC_(pTable->DoesTableExist(pTableID, &fExists), S_OK);
TESTC(!fTableExisted || fExists == !SUCCEEDED(hRes));
CLEANUP:
delete pTable;
return hRes;
} //TCITableDefinition::DropTableAndCheck
//--------------------------------------------------------------------------
//
// GetInfo about table identifiers
//--------------------------------------------------------------------------
HRESULT TCITableDefinition::GetLiteralInfo()
{
IDBInfo* pInterface = NULL;
DBLITERAL rgLiteral[2]={DBLITERAL_TABLE_NAME, DBLITERAL_COLUMN_NAME};
DBLITERALINFO* rgLiteralInfo = NULL;
ULONG cLiteralInfo, i;
OLECHAR* pCharBuffer = NULL;
IGetDataSource* pIGetDataSource=NULL; // IGetDataSource interface pointer
m_fIsIDBInfo = FALSE;
if(!VerifyInterface(m_pIOpenRowset, IID_IGetDataSource, SESSION_INTERFACE, (IUnknown**)&pIGetDataSource))
return E_FAIL;
m_hr=pIGetDataSource->GetDataSource(IID_IDBInfo,(IUnknown**)&pInterface);
SAFE_RELEASE(pIGetDataSource);
if (!CHECK(pInterface->GetLiteralInfo(2, rgLiteral, &cLiteralInfo, &rgLiteralInfo, &pCharBuffer), S_OK))
goto CLEANUP;
for (i=0; i< cLiteralInfo; i++)
{
switch (rgLiteralInfo[i].lt)
{
case DBLITERAL_TABLE_NAME:
// get the maximum size of a valid table name and the invalid chars for a table name
m_cMaxTableName = rgLiteralInfo[i].cchMaxLen;
PROVIDER_FREE(m_pwszInvalidTableChars);
m_pwszInvalidTableChars = wcsDuplicate(rgLiteralInfo[i].pwszInvalidChars?
rgLiteralInfo[i].pwszInvalidChars: L"");
break;
case DBLITERAL_COLUMN_NAME:
m_cMaxColName = rgLiteralInfo[i].cchMaxLen;
PROVIDER_FREE(m_pwszInvalidColChars);
m_pwszInvalidColChars = wcsDuplicate(rgLiteralInfo[i].pwszInvalidChars?
rgLiteralInfo[i].pwszInvalidChars: L"");
break;
}
}
m_fIsIDBInfo = TRUE;
CLEANUP:
SAFE_RELEASE(pInterface);
PROVIDER_FREE(pCharBuffer);
PROVIDER_FREE(rgLiteralInfo);
return m_hr;
} //TCITableDefinition::GetLiteralInfo
// @cmember Gets the catalog and schema name for a given table
BOOL TCITableDefinition::GetCatalogSchemaNames(
LPWSTR pwszTableName, // [in] the name of the table
LPWSTR *ppwszCatalogName, // [out] catalog name
LPWSTR *ppwszSchemaName, // [out] schema name
CTable *pTable // [in] table object (DEFAULT NULL - use m_pTable)
)
{
IRowset *pIRowset = NULL;
HROW hRow = DB_NULL_HROW;
BOOL bFound = FALSE;
WCHAR *pwszTableName1 = NULL;
CRowset Rowset;
if (!pTable)
pTable = m_pTable;
TESTC(NULL != pwszTableName);
TESTC(NULL != ppwszCatalogName);
TESTC(NULL != ppwszSchemaName);
//Obtain Schema TABLES Rowset
//We don't want to put any restrictions, since its not required to support
//restrictions...
TESTC_PROVIDER((Rowset.CreateRowset(SELECT_DBSCHEMA_TABLE,
IID_IRowset, pTable, DBACCESSOR_ROWDATA, DBPART_ALL, ALL_COLS_BOUND)==S_OK));
//Try to find the specified row with this table...
while(!bFound && S_OK == (m_hr = Rowset.GetNextRows(&hRow)))
{
//GetData for this row
TESTC_(Rowset.GetRowData(hRow, &Rowset.m_pData),S_OK);
//TABLE_NAME column
DBBINDING* pCatalogBinding = Rowset.m_rgBinding[0].iOrdinal == 0 ? &Rowset.m_rgBinding[1] : &Rowset.m_rgBinding[0];
DBBINDING* pSchemaBinding = Rowset.m_rgBinding[0].iOrdinal == 0 ? &Rowset.m_rgBinding[2] : &Rowset.m_rgBinding[1];
DBBINDING* pTableBinding = Rowset.m_rgBinding[0].iOrdinal == 0 ? &Rowset.m_rgBinding[3] : &Rowset.m_rgBinding[2];
//See if this is the correct row...
if(STATUS_BINDING(*pTableBinding, Rowset.m_pData)==DBSTATUS_S_OK)
{
//TableName
pwszTableName1 = (WCHAR*)&VALUE_BINDING(*pTableBinding, Rowset.m_pData);
bFound = FALSE;
if(CHECK(CompareID(&bFound, pwszTableName,
pwszTableName1, m_pIDBInitialize), S_OK) && bFound)
{
//Catalog Name
if(STATUS_BINDING(*pCatalogBinding, Rowset.m_pData)==DBSTATUS_S_OK)
*ppwszCatalogName = wcsDuplicate((WCHAR*)&VALUE_BINDING(*pCatalogBinding, Rowset.m_pData));
//Schema Name
if(STATUS_BINDING(*pSchemaBinding, Rowset.m_pData)==DBSTATUS_S_OK)
*ppwszSchemaName = wcsDuplicate((WCHAR*)&VALUE_BINDING(*pSchemaBinding, Rowset.m_pData));
}
}
Rowset.ReleaseRows(hRow);
hRow = DB_NULL_HROW;
}
//Error
if(!bFound)
{
TERROR("Unable to find the table \"" << pwszTableName << "\"in the Schema Rowset?");
QTESTC(bFound);
return FALSE;
}
CLEANUP:
if (DB_NULL_HROW != hRow)
Rowset.ReleaseRows(hRow);
SAFE_RELEASE(pIRowset);
return TRUE;
} //TCITableDefinition::GetCatalogSchemaNames
//--------------------------------------------------------------------------
//
// @cmember Build a valid table name of a certain length
//--------------------------------------------------------------------------
WCHAR* TCITableDefinition::BuildValidName(size_t length, WCHAR* pattern)
{
WCHAR* pwszBuffer = NULL;
size_t cLen = wcslen(pattern), i;
SAFE_ALLOC(pwszBuffer, WCHAR, i=(length+1));
memset(pwszBuffer, 0, i);
for (i=0; i< length - cLen; i+=cLen)
wcscat(pwszBuffer, pattern);
// manage the rest of the characters
wcsncat(pwszBuffer, pattern, length-i);
CLEANUP:
return pwszBuffer;
} //TCITableDefinition::BuildValidName
//--------------------------------------------------------------------------
//
// @cmember Build an invalid table name of a certain length
// the pattern is supposed to be shorter than the string to be build
//--------------------------------------------------------------------------
WCHAR* TCITableDefinition::BuildInvalidName(size_t length, WCHAR* pattern, WCHAR* invchars)
{
WCHAR* pwszBuffer=NULL;
size_t cLen = wcslen(pattern), i, cInvLen=wcslen(invchars);
pwszBuffer = (WCHAR*) PROVIDER_ALLOC( (length + 1) * sizeof(WCHAR) );
if (!pwszBuffer)
goto CLEANUP;
if (length > cInvLen+cLen)
{
wcscpy(pwszBuffer, pattern);
wcscat(pwszBuffer, invchars);
}
else
{
wcscpy(pwszBuffer, L"aa");
wcsncat(pwszBuffer, invchars, length-wcslen(pwszBuffer)-1);
pwszBuffer[length] = 0;
assert( wcslen(pwszBuffer) < length );
return pwszBuffer;
}
for (i=wcslen(pwszBuffer); i< length - cLen; i+=cLen)
wcscat(pwszBuffer, pattern);
// manage the rest of the characters
for (; i<length; i++)
wcscat(pwszBuffer, L"a");
CLEANUP:
return pwszBuffer;
} //TCITableDefinition::BuildInvalidName
//---------------------------------------------------------------------
//
// @cmember Uses m_pTable to get a column description for all types
//---------------------------------------------------------------------
void TCITableDefinition::GetProviderTypes(void)
{
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
if (m_pTable)
delete m_pTable;
m_pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the provider types list
// all types appear in CreateColList, so I don't have to use CreateTypeColInfo
m_pTable->CreateTypeColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
m_pTable->DuplicateColList(m_ColList);
// in m_rgColumnDesc I would rather load just the types prepared for table creation
m_pTable->CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
m_pTable->BuildColumnDescs(&m_rgColumnDesc);
m_cColumnDesc = m_pTable->CountColumnsOnTable();
m_pTable->SetBuildColumnDesc(FALSE);
ReleaseAllColumnPropSets(m_rgColumnDesc, m_cColumnDesc);
delete m_pTable;
m_pTable = NULL;
} //TCITableDefinition::GetProviderTypes
//---------------------------------------------------------------------
//
// @cmember Sets all the columns to maximum size as got from m_ColList
// (based on information read from PROVIDER_TYPES Rowset)
//
// RESULT:
// TRUE - set for every element in column desc array
// FALSE - could not be set for every element in thee array
//---------------------------------------------------------------------
BOOL TCITableDefinition::SetMaximumColSize
(
DBCOLUMNDESC *rgColumnDesc,
DBORDINAL cColumnDesc
)
{
POSITION pos;
CCol col;
DBORDINAL i;
WCHAR *pwszType;
for (i=0; i<cColumnDesc; i++)
{
pwszType = GetColumnTypeName(&rgColumnDesc[i]);
// look for the type which fits with column type
for ( pos=m_ColList.GetHeadPosition(), col=m_ColList.GetNext(pos);
wcscmp(col.GetProviderTypeName(), pwszType) && pos;
col=m_ColList.GetNext(pos));
if (wcscmp(col.GetProviderTypeName(), pwszType) )
continue;
// set to max column size
rgColumnDesc[i].ulColumnSize = col.GetColumnSize();
}
return TRUE;
} //TCITableDefinition::SetMaximumColSize
//--------------------------------------------------------------------------
//
// @cmember Sets all the column sizes to 0
// RESULT:
// TRUE - set for every element in column desc array
// FALSE - could not be set for every element in thee array
//--------------------------------------------------------------------------
BOOL TCITableDefinition::SetZeroColSize
(
DBCOLUMNDESC *rgColumnDesc,
DBORDINAL cColumnDesc
)
{
DBORDINAL i;
for (i=0; i<cColumnDesc; i++)
{
// set column size to 0
rgColumnDesc[i].ulColumnSize = 0;
}
return TRUE;
} //TCITableDefinition::SetZeroColSize
//--------------------------------------------------------------------------
//
// @cmember CheckReturnedDBID about the columns in the table
// pIndexID - [IN] the DBID asked for
// ppIndexID - [IN] the DBID created
//--------------------------------------------------------------------------
BOOL TCITableDefinition::CheckReturnedDBID(
DBID *pIndexID, // passed to CreateIndex
DBID **ppIndexID // returned by CreateIndex
)
{
if (!pIndexID)
return *ppIndexID != NULL;
if (!ppIndexID)
{
return TRUE;
}
if (*ppIndexID == NULL)
return FALSE;
if (pIndexID->eKind != (*ppIndexID)->eKind)
return TRUE;
return CompareDBID(*pIndexID, **ppIndexID);
} //TCITableDefinition::CheckReturnedDBID
//--------------------------------------------------------------------------
//
// @cmember GetInfo about the columns in the table
// prgInfo - [OUT] the array of column information
// pcColumns - [OUT] the size of the array
// ppStringBuffer - [OUT] memory for info in the array
//--------------------------------------------------------------------------
BOOL TCITableDefinition::GetColumnInfo
(
DBID *pTableID,
DBORDINAL *pcColumns,
DBCOLUMNINFO **prgInfo,
OLECHAR **ppStringBuffer
)
{
IColumnsInfo *pIColumnsInfo;
if ( (m_hr = m_pIOpenRowset->OpenRowset(NULL, pTableID, NULL, IID_IColumnsInfo,
0, NULL, (IUnknown**)&pIColumnsInfo)) != S_OK)
{
*prgInfo = NULL;
*pcColumns = 0;
*ppStringBuffer = NULL;
return FALSE;
}
if (!CHECK(m_hr = pIColumnsInfo->GetColumnInfo(pcColumns, prgInfo, ppStringBuffer), S_OK))
return FALSE;
SAFE_RELEASE(pIColumnsInfo);
return TRUE;
} //TCITableDefinition::GetColumnInfo
//---------------------------------------------------------------------
//
// @cmember Get an array od Column Descriptors on a Table
//---------------------------------------------------------------------
BOOL TCITableDefinition::GetColumnDescOnTable(
DBID *pTableID,
DBCOLUMNDESC **prgColumnDesc,
DBORDINAL *cColumnDesc
)
{
if (!m_pTable)
return FALSE;
// get info in m_pTable->m_ColList
m_pTable->GetTableColumnInfo(pTableID);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
pTableID || DBKIND_NAME != pTableID->eKind? pTableID->uName.pwszName: NULL);
m_pTable->ColList2ColumnDesc(prgColumnDesc, cColumnDesc);
return TRUE;
} //TCITableDefinition::GetColumnDescOnTable
//---------------------------------------------------------------------
//
// @cmember Passes a type name and retrieves the column from m_ColList with info about that type
//---------------------------------------------------------------------
CCol TCITableDefinition::GetType(WCHAR *pwszTypeName, DBTYPE wType, BOOL *fExists)
{
POSITION pos;
CCol col;
BOOL fRes = FALSE;
for (pos = m_ColList.GetHeadPosition(); pos && !fRes; )
{
col = m_ColList.GetNext(pos);
fRes = (0 == wcscmp(col.GetProviderTypeName(), pwszTypeName))
&& (wType == col.GetProviderType());
}
if (fExists)
*fExists = fRes;
return fRes? col : m_ColList.GetHead();
} //TCITableDefinition::GetType
//------------------------------------------------------------------------
//
// @mfunc Check whether the array of ColumnDesc sent was preserved
// @rdesc TRUE or FALSE
// All the data should be inside, the only thing that is allowed to be modified <nl>
// is the property status
//------------------------------------------------------------------------
BOOL TCITableDefinition::IsColumnDescPreserved
(
DBCOLUMNDESC *rgInColumnDesc, // the array passed to ITableDefinition::CreateTable
DBCOLUMNDESC *rgOutColumnDesc, // the aray returned by ITableDefinition::CreateTable
DBORDINAL cColumnDesc // the size of the arrays
)
{
// when this function is called, it is supposed that m_HasAuto... were set by GetTableColumnInfo
// and unmodified ever since
ULONG i, cPropSets, cProp;
DBPROPSET *pInPropSet, *pOutPropSet;
if (NULL == rgInColumnDesc || NULL == rgOutColumnDesc)
return (0 == cColumnDesc) || (rgOutColumnDesc == rgInColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
// compare everything in the stru
if (!CHECK(rgInColumnDesc[i].pTypeInfo == rgOutColumnDesc[i].pTypeInfo, TRUE))
return FALSE;
if (!CHECK(rgInColumnDesc[i].ulColumnSize == rgOutColumnDesc[i].ulColumnSize, TRUE))
return FALSE;
if (!CHECK(rgInColumnDesc[i].wType == rgOutColumnDesc[i].wType, TRUE))
return FALSE;
if (!CHECK(rgInColumnDesc[i].bPrecision == rgOutColumnDesc[i].bPrecision, TRUE))
return FALSE;
if (!CHECK(rgInColumnDesc[i].bScale == rgOutColumnDesc[i].bScale, TRUE))
return FALSE;
if (!CHECK(rgInColumnDesc[i].pclsid == rgOutColumnDesc[i].pclsid, TRUE))
return FALSE;
if (INVALID_DBKIND != rgInColumnDesc[i].dbcid.eKind)
{
// CompareDBID with NULL DSO interface since the ids should
// match exactly
if (!CHECK(m_hr = CompareDBID(rgInColumnDesc[i].dbcid,
rgOutColumnDesc[i].dbcid, NULL), TRUE))
return FALSE;
}
else
if (INVALID_DBKIND != rgOutColumnDesc[i].dbcid.eKind)
return FALSE;
// compare the properties
if (!CHECK(rgInColumnDesc[i].cPropertySets == rgOutColumnDesc[i].cPropertySets, TRUE))
return FALSE;
if ( (NULL == rgInColumnDesc[i].rgPropertySets)
|| (NULL == rgOutColumnDesc[i].rgPropertySets))
if ( 0 != rgOutColumnDesc[i].cPropertySets
&& !COMPARE(rgInColumnDesc[i].rgPropertySets, rgOutColumnDesc[i].rgPropertySets))
return FALSE;
else
continue;
for (cPropSets=0; cPropSets<rgInColumnDesc[i].cPropertySets; cPropSets++)
{
// compare the props in that prop set
pInPropSet = &(rgInColumnDesc[i].rgPropertySets[cPropSets]);
pOutPropSet = &(rgOutColumnDesc[i].rgPropertySets[cPropSets]);
if (!CHECK(pInPropSet->guidPropertySet == pOutPropSet->guidPropertySet, TRUE))
return FALSE;
if (!CHECK(pInPropSet->cProperties == pOutPropSet->cProperties, TRUE))
return FALSE;
if ( (NULL == pInPropSet->rgProperties)
|| (NULL == pOutPropSet->rgProperties))
if (0 != pOutPropSet->cProperties
&& !COMPARE(pInPropSet->rgProperties, pOutPropSet->rgProperties))
return FALSE;
else
continue;
// compare the properties
for (cProp=0; cProp<pInPropSet->cProperties; cProp++)
{
if (!CHECK(pInPropSet->rgProperties[cProp].dwPropertyID ==
pOutPropSet->rgProperties[cProp].dwPropertyID, TRUE))
return FALSE;
if (!CHECK(pInPropSet->rgProperties[cProp].dwOptions ==
pOutPropSet->rgProperties[cProp].dwOptions, TRUE))
return FALSE;
// use NULL fr DSO interface
if (!CHECK(m_hr = CompareDBID(pInPropSet->rgProperties[cProp].colid,
pOutPropSet->rgProperties[cProp].colid,
NULL), TRUE))
return FALSE;
// protection against assertion errors in CompareVariant
if (
(rgInColumnDesc[i].wType != DBTYPE_GUID) &&
(rgInColumnDesc[i].wType != DBTYPE_BYTES) &&
(rgInColumnDesc[i].wType != DBTYPE_STR) &&
(rgInColumnDesc[i].wType != DBTYPE_WSTR) &&
(rgInColumnDesc[i].wType != DBTYPE_NUMERIC) &&
(rgInColumnDesc[i].wType != DBTYPE_DBTIMESTAMP)
)
if (!CHECK(CompareVariant(&pInPropSet->rgProperties[cProp].vValue,
&pOutPropSet->rgProperties[cProp].vValue), TRUE))
return FALSE;
}
}
}
return TRUE;
} //TCITableDefinition::IsColumnDescPreserved
//---------------------------------------------------------------------
//
// @cmember Set a property in the property sets of a DBCOLUMNDESC
//---------------------------------------------------------------------
BOOL TCITableDefinition::SetProperty
(
DBPROPSET **prgPropertySets, // [in/out] array of property sets
ULONG *pcPropertySets, // [in/out] number of property sets
DBPROPID propID, // [in] property ID
DBTYPE wType, // [in] value type
LPVOID value, // [in] property value
DBPROPOPTIONS dwOption/*=DPROPOPTIONS_OPTIONAL*/, // [in] prop options
DBID colid/*=DB_NULLID*/, // [in] col id
GUID guidPropertySet/*DBPROPSET_COLUMN*/,// [in] the GUID of the propset
ULONG *pcPropSet/*=NULL*/, // [out] index of property set
ULONG *pcProp/*=NULL*/ // [out] index in the rgProperties array
)
{
LONG i;
DBPROPSET *pPropSet;
BOOL fRes = FALSE, fFound;
ULONG cPropSet, cProp;
if (wType != DBTYPE_VARIANT)
{
TESTC(::SetProperty(propID, guidPropertySet, pcPropertySets, prgPropertySets, value,
wType, dwOption, colid));
}
else
{
TESTC(::SetProperty(propID, guidPropertySet, pcPropertySets, prgPropertySets, value,
VT_I2, dwOption, colid));
}
fRes = TRUE;
for (i=(int)(*pcPropertySets - 1), fFound = FALSE; i >= 0 && !fFound; i--)
{
fFound = (*prgPropertySets)[i].guidPropertySet == guidPropertySet;
cPropSet = (ULONG)i;
}
TESTC(fFound);
pPropSet = &((*prgPropertySets)[cPropSet]);
for (i=pPropSet->cProperties - 1, fFound = FALSE; i >= 0 && !fFound; i--)
{
if (TRUE == (fFound = pPropSet->rgProperties[i].dwPropertyID == propID))
{
cProp = (ULONG)i;
if (DBTYPE_VARIANT == wType)
{
pPropSet->rgProperties[i].vValue.vt = ((VARIANT*)value)->vt;
FillVariant(&pPropSet->rgProperties[i].vValue);
}
}
}
if (pcPropSet)
*pcPropSet = cPropSet;
if (pcProp)
*pcProp = cProp;
TESTC(fFound);
fRes = TRUE;
CLEANUP:
return fRes;
} //TCITableDefinition::SetProperty
//---------------------------------------------------------------------------
//
// @cmember Set a default property in the property sets of a DBCOLUMNDESC
//---------------------------------------------------------------------------
BOOL TCITableDefinition::SetDefaultProperty(
DBPROPSET **prgPropertySets, // [in/out] array of property sets
ULONG *pcPropertySets, // [in/out] number of property sets
VARIANT *pvalue, // [in] property value
DBPROPOPTIONS dwOption /*= DBPROPOPTIONS_OPTIONAL*/, // [in] prop options
DBID colid /*= DB_NULLID*/, // [in] col id
GUID guidPropertySet /*= DBPROPSET_COLUMN*/, // [in] the GUID of the propset
ULONG *pcPropSet /*= NULL*/, // [out] index of property set
ULONG *pcProp /*=NULL*/ // [out] index in the rgProperties array
)
{
BOOL fRes = FALSE;
ULONG cPropSet;
ULONG cProp;
TESTC(NULL != pvalue);
TESTC(SetProperty(prgPropertySets, pcPropertySets, DBPROP_COL_DEFAULT,
DBTYPE_I2, 0, dwOption, colid, DBPROPSET_COLUMN, &cPropSet, &cProp));
VariantCopy(&((*prgPropertySets)[cPropSet].rgProperties[cProp].vValue), pvalue);
if (pcPropSet)
*pcPropSet = cPropSet;
if (pcProp)
*pcProp = cProp;
fRes = TRUE;
CLEANUP:
return fRes;
} // TCITableDefinition::SetDefaultProperty
//---------------------------------------------------------------------------
// TCITableDefinition::Insert
//
// CTable |
// Insert |
// Inserts 1 row in table using IRowsetNewRow. This function is called
// by the pulic Insert function.
//
// @mfunc Insert
// @rdesc HRESULT indicating success or failure
// @flag S_OK | Function ran without problem
// @flag E_FAIL | No Columns Marked for use or SetNewData failed
//
//---------------------------------------------------------------------------
HRESULT TCITableDefinition::Insert(
DBCOUNTITEM ulRowNumber, // @parm [IN] Row number to insert (0 for next)
IUnknown *pIUnknown, // @parm [IN] Pointer to rowset interface
ULONG cNulls, // @parm [IN] Number of columns to be set to NULL (DEFAULT 0)
DBORDINAL *rgNulls, // @parm [IN] Array of columns to be set to NULL (DEFAULT NULL)
CTable *pTable // @parm [IN] Table (DEFAULT NULL - use m_pTable)
)
{
HRESULT hr = E_FAIL;
HACCESSOR hAccessor = NULL;
BYTE* pData = NULL;
DBCOUNTITEM cBindings = 0;
DBBINDING* rgBindings = NULL;
IDBProperties* pIDBProperties = NULL;
IGetDataSource* pIGetDataSource = NULL;
ULONG nBinding, nNull;
BOOL fFound;
IRowsetChange *pIRowsetChange = NULL;
IAccessor *pIAccessor = NULL;
ULONG cRefCounts = ULONG_MAX;
if (!pTable)
pTable = m_pTable;
// Find row number to use on insert
if (ulRowNumber == 0)
ulRowNumber = pTable->GetNextRowNumber();
TESTC(NULL != pIUnknown);
TESTC(VerifyInterface(pIUnknown, IID_IAccessor, ROWSET_INTERFACE, (IUnknown**)&pIAccessor));
TESTC(VerifyInterface(pIUnknown, IID_IRowsetChange, ROWSET_INTERFACE, (IUnknown**)&pIRowsetChange));
//Get the DataSource
TESTC(VerifyInterface(m_pIOpenRowset, IID_IGetDataSource, SESSION_INTERFACE, (IUnknown**)&pIGetDataSource));
TESTC_(hr = pIGetDataSource->GetDataSource(IID_IDBProperties, (IUnknown**)&pIDBProperties), S_OK);
//Get an accessor with all the writeable columns
TESTC_(hr = GetAccessorAndBindings(pIRowsetChange,
DBACCESSOR_ROWDATA,
&hAccessor, &rgBindings, &cBindings, NULL,
DBPART_VALUE |DBPART_STATUS |DBPART_LENGTH,
UPDATEABLE_COLS_BOUND, FORWARD, NO_COLS_BY_REF, NULL,
NULL, NULL, DBTYPE_EMPTY, 0, NULL), S_OK);
// Fill buffer with appropriate data for insert of this row number
TESTC_(hr = FillInputBindings(
pTable,
DBACCESSOR_ROWDATA,
cBindings,
rgBindings,
&pData,
ulRowNumber,
0,
NULL),S_OK);
// set the NULL columns
for (nBinding = 0; nBinding < cBindings; nBinding++)
{
for (fFound = FALSE, nNull = 0; nNull < cNulls && !fFound; nNull++)
{
if (rgBindings[nBinding].iOrdinal == rgNulls[nNull])
{
*(DBSTATUS*)(pData+rgBindings[nBinding].obStatus) = DBSTATUS_S_ISNULL;
fFound = TRUE;
}
}
}
// release previous accessor and create a new one
hr = pIRowsetChange->InsertRow(NULL, hAccessor, pData, NULL);
if (DB_E_ERRORSOCCURRED == hr)
{
SHORT *pMyData;
for (ULONG i=0; i<cBindings; i++)
{
pMyData = (SHORT*)(pData+rgBindings[i].obStatus);
if (DBSTATUS_S_OK != *pMyData && DBSTATUS_E_UNAVAILABLE != *pMyData)
odtLog << "bindings " << i << "\n";
}
}
// We have successfully inserted if we got this far
pTable->AddRow(); //increments pTable->m_ulNextRow
CLEANUP:
if(hAccessor && pIAccessor)
{
pIAccessor->ReleaseAccessor(hAccessor, &cRefCounts);
COMPARE(cRefCounts,0);
}
SAFE_RELEASE(pIAccessor);
FreeAccessorBindings(cBindings, rgBindings);
PROVIDER_FREE(pData);
SAFE_RELEASE(pIRowsetChange);
SAFE_RELEASE(pIGetDataSource);
SAFE_RELEASE(pIDBProperties);
return hr;
} //TCITableDefinition::Insert
//--------------------------------------------------------------------------
//
// @cmember StartTransaction method
// RETURN
// S_OK - an isolation level could be set and a transaction started
// E_FAIL - could not start a transaction
//--------------------------------------------------------------------------
HRESULT TCITableDefinition::StartTransaction(ITransactionLocal *pITransactionLocal)
{
ULONG n, i;
HRESULT hr;
ISOLEVEL rgIsoLevel[] = {ISOLATIONLEVEL_BROWSE, ISOLATIONLEVEL_CURSORSTABILITY,
ISOLATIONLEVEL_ISOLATED, ISOLATIONLEVEL_CHAOS};
if (NULL == pITransactionLocal)
return E_FAIL;
n = NUMELEM(rgIsoLevel);
for (i=0; i<n; i++)
{
if (S_OK == (hr = pITransactionLocal->StartTransaction(rgIsoLevel[i], 0, NULL, NULL)))
{
return S_OK;
}
}
return E_FAIL;
} //TCITableDefinition::StartTransaction
//---------------------------------------------------------------------
//
// TCITableDefinition::AddColumnAndCheck
//
// Add a column to the table and check the result
// RETURN value is the ret value of ITableDefinition::AddColumn
//---------------------------------------------------------------------
HRESULT TCITableDefinition::AddColumnAndCheck(
DBID *pTableID, // [IN] table ID
DBCOLUMNDESC *pColumnDesc, // [IN] descriptor of the column to be added
DBID **ppColumnID, // [OUT] column ID for the resulted column
ITableDefinition *pITableDefinition,/*= NULL*/// [IN] pointer to ITableDefinition
DBID *pBaseTableID/*= NULL*/ // [IN] if provided, this is the table DBID that should be used
// in metadata comparison (e.g. pTableID might be the qualified name)
)
// sometimes there is not a unique expected result (e.g. one property could be supported or not)
// using Validate == FALSE you can protect the code from getting errors
{
DBCOLUMNDESC *rgOldCD = NULL;
DBORDINAL nOldlen = 0;
DBCOLUMNDESC *rgNewCD = NULL;
DBORDINAL nNewlen = 0;
DBCOLUMNDESC *pOriginalColumnDesc = NULL;
BOOL fRes = TRUE;
HRESULT hr = E_FAIL;
if (!pBaseTableID)
pBaseTableID = pTableID;
pITableDefinition = (NULL == pITableDefinition) ? m_pITableDefinition: pITableDefinition;
TESTC(NULL != pITableDefinition);
GetColumnDescOnTable(pBaseTableID, &rgOldCD, &nOldlen);
if (ppColumnID)
*ppColumnID = NULL;
CHECK(NULL == pColumnDesc
|| NULL != DuplicateColumnDesc(pColumnDesc, 1, &pOriginalColumnDesc), TRUE);
// here use pTableID, everywhere else use pBaseTableID
hr = pITableDefinition->AddColumn(pTableID, pColumnDesc, ppColumnID);
if ( pOriginalColumnDesc
&& !COMPARE(IsColumnDescPreserved(pOriginalColumnDesc, pColumnDesc, 1), TRUE))
{
odtLog << "\tERROR: column desc is not preserved\n";
}
// check the status of the column properties
COMPARE(CheckColPropStatus(1, pColumnDesc, hr), TRUE);
if (FAILED(hr) && ppColumnID)
COMPARE(NULL == *ppColumnID, TRUE);
// get the new stru of the table
GetColumnDescOnTable(pBaseTableID, &rgNewCD, &nNewlen);
// check the result of the operation
if (SUCCEEDED(hr))
// get info about the columns in the altered table and compare them, one by one!
COMPARE(CheckColInfo(rgOldCD, nOldlen, rgNewCD, nNewlen, pColumnDesc), TRUE);
else
// make sure that the table stru remained the same
COMPARE(AreColEqual(rgOldCD, nOldlen, rgNewCD, nNewlen), TRUE);
CLEANUP:
// save old values into the new ones and release the others
ReleaseColumnDesc(rgOldCD, nOldlen);
ReleaseColumnDesc(rgNewCD, nNewlen);
ReleaseColumnDesc(pOriginalColumnDesc, 1);
return hr;
} //TCITableDefinition::AddColumnAndCheck
//---------------------------------------------------------------------
//
// @member Create the table using ITableDefinition::CreateTable and
// check its creation
//---------------------------------------------------------------------
HRESULT TCITableDefinition::CreateAndCheckTable(
ITableDefinition *pITableDefinition, // [in] pointer to the ITableDefinition interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
)
{
BOOL fExists;
DBORDINAL cOriginalColumnDescs = 0;
DBCOLUMNDESC *rgOriginalColumnDescs = NULL;
ULONG cOriginalPropertySets = 0;
DBPROPSET *rgOriginalPropertySets = NULL;
HRESULT hres;
DBID *pNewTableID = NULL;
CTable *pTable = new CTable(pITableDefinition, (LPWSTR)gwszModuleName);
IUnknown *pIUnknown = NULL; // used to pass the rowset pointer to AreColumnsCreatedOK
ASSERT(pTable);
ASSERT(pITableDefinition);
// save the original values
CHECK(0 == cColumnDescs || NULL == rgColumnDescs
|| NULL != DuplicateColumnDesc(rgColumnDescs, cColumnDescs, &rgOriginalColumnDescs), TRUE);
cOriginalColumnDescs = cColumnDescs;
CHECK(0 == cPropertySets || NULL == rgPropertySets
|| DuplicatePropertySets(cPropertySets, rgPropertySets, &cOriginalPropertySets, &rgOriginalPropertySets), TRUE);
// go for ITableDefinition::CreateTable
hres = pITableDefinition->CreateTable(pUnkOuter, pTableID, cColumnDescs, rgColumnDescs, riid,
cPropertySets, rgPropertySets, ppTableID, ppRowset);
if (SUCCEEDED(hres))
{
COMPARE(NULL == ppTableID || NULL != *ppTableID, TRUE);
}
else
{
COMPARE(NULL == ppTableID || NULL == *ppTableID, TRUE);
}
if (rgOriginalColumnDescs
&& !COMPARE(IsColumnDescPreserved(rgOriginalColumnDescs, rgColumnDescs, cColumnDescs), TRUE))
{
odtLog << "\tERROR: array of column desc is not preserved\n";
}
if ( rgOriginalPropertySets
&& !COMPARE(IsRowsetPropSetPreserved(rgOriginalPropertySets, rgPropertySets, cPropertySets), TRUE))
{
odtLog << "\tERROR: the rowset property sets are not preserved\n";
}
COMPARE(CheckRwstTblPropStatus(cPropertySets, rgPropertySets, hres), TRUE);
COMPARE(CheckColPropStatus(cColumnDescs, rgColumnDescs, hres), TRUE);
pNewTableID = (ppTableID)? (*ppTableID): pTableID;
// if the table creation was reported as succeding, the table should exist
if ( SUCCEEDED(hres)
&& (!CHECK(pTable->DoesTableExist(pNewTableID, &fExists), S_OK) || !fExists))
{
if (!fExists)
odtLog << "\tERROR: despite the return value reported, the table doesn't exist\n";
}
// if the table creation was reported as failed, the table should not exist
if ( FAILED(hres)
&& DB_E_DUPLICATETABLEID != hres
&& DB_E_NOTABLE != hres
&& pNewTableID
&& (!CHECK(pTable->DoesTableExist(pNewTableID, &fExists), S_OK) || fExists))
{
if (!fExists)
odtLog << "\tERROR: despite the return value reported, the table exists\n";
}
if (SUCCEEDED(hres))
{
pIUnknown = (ppRowset) ? (IUnknown*)(*ppRowset) : NULL;
COMPARE(AreColumnsCreatedOK(rgColumnDescs, cColumnDescs, pNewTableID, pIUnknown), TRUE);
if (ppRowset)
{
COMPARE(IsRowsetPropSetCreatedOK(rgPropertySets, cPropertySets, *ppRowset), TRUE);
COMPARE(!ppRowset || CheckRowset(*ppRowset), TRUE);
}
COMPARE(CheckReturnedDBID(pTableID, ppTableID), TRUE);
}
else
{
COMPARE(ppRowset && NULL == *ppRowset, TRUE);
COMPARE(!ppTableID || NULL == *ppTableID, TRUE);
}
delete pTable;
ReleaseColumnDesc(rgOriginalColumnDescs, cOriginalColumnDescs);
FreeProperties( &cOriginalPropertySets, &rgOriginalPropertySets);
return hres;
} //TCITableDefinition::CreateAndCheckTable
//---------------------------------------------------------------------
//
// @member Create the table using ITableDefinitionWithConstraints::CreateTableWithConstraints and
// check its creation
//---------------------------------------------------------------------
HRESULT TCITableDefinition::CreateAndCheckTableWithConstraints(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
ULONG cConstraintDescs, // [in] the number of constraints to be created
DBCONSTRAINTDESC *rgConstraintDescs, // [in/out] array of constraints
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
)
{
BOOL fExists;
DBORDINAL cOriginalColumnDescs = 0;
DBCOLUMNDESC *rgOriginalColumnDescs = NULL;
ULONG cOriginalPropertySets = 0;
DBPROPSET *rgOriginalPropertySets = NULL;
HRESULT hres;
DBID *pNewTableID = NULL;
CTable *pTable = new CTable(pITableDefinitionWithConstraints, (LPWSTR)gwszModuleName);
IUnknown *pIUnknown = NULL; // used to pass the rowset pointer to AreColumnsCreatedOK
CConstraints Constraints(pITableDefinitionWithConstraints);
DBORDINAL index;
ASSERT(pTable);
ASSERT(pITableDefinitionWithConstraints);
// save the original values
CHECK(0 == cColumnDescs || NULL == rgColumnDescs
|| NULL != DuplicateColumnDesc(rgColumnDescs, cColumnDescs, &rgOriginalColumnDescs), TRUE);
cOriginalColumnDescs = cColumnDescs;
CHECK(0 == cPropertySets || NULL == rgPropertySets
|| DuplicatePropertySets(cPropertySets, rgPropertySets, &cOriginalPropertySets, &rgOriginalPropertySets), TRUE);
// get original constraint set
if (pTableID && (DBKIND_NAME == pTableID->eKind) && pTableID->uName.pwszName)
{
CHECK(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
}
// go for ITableDefinition::CreateTable
hres = pITableDefinitionWithConstraints->CreateTableWithConstraints(pUnkOuter,
pTableID, cColumnDescs, rgColumnDescs, cConstraintDescs, rgConstraintDescs,
riid, cPropertySets, rgPropertySets, ppTableID, ppRowset);
if ( rgOriginalColumnDescs
&& !COMPARE(IsColumnDescPreserved(rgOriginalColumnDescs, rgColumnDescs, cColumnDescs), TRUE))
{
odtLog << "\tERROR: array of column desc is not preserved\n";
}
if ( rgOriginalPropertySets
&& !COMPARE(IsRowsetPropSetPreserved(rgOriginalPropertySets, rgPropertySets, cPropertySets), TRUE))
{
odtLog << "\tERROR: the rowset property sets are not preserved\n";
}
COMPARE(CheckRwstTblPropStatus(cPropertySets, rgPropertySets, hres), TRUE);
COMPARE(CheckColPropStatus(cColumnDescs, rgColumnDescs, hres), TRUE);
pNewTableID = (ppTableID)? (*ppTableID): pTableID;
// if the table creation was reported as succeding, the table should exist
if ( SUCCEEDED(hres)
&& (!CHECK(pTable->DoesTableExist(pNewTableID, &fExists), S_OK) || !fExists))
{
if (!fExists)
odtLog << "\tERROR: despite the return value reported, the table doesn't exist\n";
}
// if the table creation was reported as failed, the table should not exist
if ( FAILED(hres)
&& DB_E_DUPLICATETABLEID != hres
&& DB_E_NOTABLE != hres
&& pNewTableID
&& (!CHECK(pTable->DoesTableExist(pNewTableID, &fExists), S_OK) || fExists))
{
if (!fExists)
odtLog << "\tERROR: despite the return value reported, the table exists\n";
}
if (SUCCEEDED(hres))
{
pIUnknown = (ppRowset) ? (IUnknown*)(*ppRowset) : NULL;
COMPARE(AreColumnsCreatedOK(rgColumnDescs, cColumnDescs, pNewTableID, pIUnknown), TRUE);
if (ppRowset)
{
COMPARE(IsRowsetPropSetCreatedOK(rgPropertySets, cPropertySets, *ppRowset), TRUE);
COMPARE(!ppRowset || CheckRowset(*ppRowset), TRUE);
}
COMPARE(CheckReturnedDBID(pTableID, ppTableID), TRUE);
// check constraint creation
if (pNewTableID && (DBKIND_NAME == pNewTableID->eKind) && pNewTableID->uName.pwszName)
{
CHECK(Constraints.GetConstraints(NULL, NULL, pNewTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
// the number of constraints created is greater than or equal to cConstraintDescs
// this happens because the user can ask for some more constraints using column props
COMPARE(Constraints.GetConstrNo() >= cConstraintDescs, TRUE);
for (index = 0; index < cConstraintDescs; index++)
{
// BEWARE: if deferred flag was set without deferrable
// flag being set, constraint should be immediate
if (rgConstraintDescs[index].Deferrability == DBDEFERRABILITY_DEFERRABLE)
rgConstraintDescs[index].Deferrability = 0;
}
CHECK(Constraints.CheckIncludedConstraints(cConstraintDescs, rgConstraintDescs), S_OK);
}
}
else
{
COMPARE(NULL == ppRowset || NULL == *ppRowset, TRUE);
COMPARE(NULL == ppTableID || NULL == *ppTableID, TRUE);
// check no constraints existed on the table
if (DB_E_DUPLICATETABLEID == hres)
{
CHECK(Constraints.AreConstraintsPreserved(), S_OK);
}
else
{
// make sure no constraints exist for this table name (if not invalid)
if (pTableID && (DBKIND_NAME == pTableID->eKind) && pTableID->uName.pwszName)
{
CHECK(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
COMPARE(Constraints.GetConstrNo(), 0);
}
}
}
delete pTable;
ReleaseColumnDesc(rgOriginalColumnDescs, cOriginalColumnDescs);
FreeProperties( &cOriginalPropertySets, &rgOriginalPropertySets);
return hres;
} //TCITableDefinition::CreateAndCheckTableWithConstraints
// Add a constraint to a table using ITableDefinitionWithConstraints::AddConstraint and check its creation
HRESULT TCITableDefinition::AddConstraintAndCheck(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
DBID *pTableID, // [in] pointer to the input table ID
DBCONSTRAINTDESC *pConstraintDesc, // [in] new constraint
BOOL fDifferentColTypesInFK
)
{
// this method assumes that the table indicated by pTableID does exist
HRESULT hr = E_FAIL;
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(pITableDefinitionWithConstraints);
DBID *pConstraintID;
ULONG index;
// keep trace of whether the constraint DBID was NULL
pConstraintID = pConstraintDesc? pConstraintDesc->pConstraintID: NULL;
TESTC(NULL != pITableDefinitionWithConstraints);
// get all the constraints associated with the table
if (pTableID && DBKIND_NAME == pTableID->eKind)
{
TESTC_(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
}
else
{
TESTC_(Constraints.GetConstraints(NULL, NULL, NULL, NULL, NULL, NULL), S_OK);
}
hr = pITableDefinitionWithConstraints->AddConstraint(pTableID, pConstraintDesc);
// check that constraint ID is not modified if set to NULL
COMPARE(!pConstraintDesc || (pConstraintID == pConstraintDesc->pConstraintID), TRUE);
// check that the result is one of the expected results
TESTC(CheckResult(hr, cValidHRes, rgValidHRes));
if (FAILED(hr))
{
CHECK(Constraints.AreConstraintsPreserved(), S_OK);
}
else
{
TESTC(NULL != pTableID);
// check that the constraint was added
DBDEFERRABILITY def = pConstraintDesc->Deferrability;
// BEWARE: if deferred flag was set without deferrable
// flag being set, constraint should be immediate
if (pConstraintDesc->Deferrability == DBDEFERRABILITY_DEFERRABLE)
pConstraintDesc->Deferrability = 0;
CHECK(Constraints.CheckAddConstraints(1, pConstraintDesc), S_OK);
pConstraintDesc->Deferrability = def;
}
switch (hr)
{
case S_OK:
break;
case E_INVALIDARG:
// check the returned value condition (assume only one of them was set, if any)
TESTC( NULL == pTableID || NULL == pConstraintDesc
|| 0 < pConstraintDesc->cForeignKeyColumns && NULL == pConstraintDesc->rgForeignKeyColumnList
|| 0 < pConstraintDesc->cForeignKeyColumns && pConstraintDesc->cColumns != pConstraintDesc->cForeignKeyColumns
|| 0 < pConstraintDesc->cColumns && NULL == pConstraintDesc->rgColumnList
|| 0 != pConstraintDesc->cReserved && NULL == pConstraintDesc->rgReserved);
break;
case DB_E_BADCONSTRAINTID:
// conditions for DB_E_BADCONSTRAINTID
break;
case DB_E_DUPLICATECONSTRAINTID:
// condition for DB_E_DUPLICATECONSTRAINTID
if ( (NULL == Constraints[pConstraintDesc->pConstraintID])
&& (pTableID && DBKIND_NAME == pTableID->eKind))
{
DBCONSTRAINTDESC *pConstraintDesc = Constraints.GetConstraints();
// or there is a primary constraint on this table
for (index = 0; index < Constraints.GetConstrNo(); index++)
{
if (DBCONSTRAINTTYPE_PRIMARYKEY == pConstraintDesc->ConstraintType)
break;
}
TESTC(index < Constraints.GetConstrNo());
}
break;
case DB_E_BADCONSTRAINTTYPE:
// condition for DB_E_BADCONSTRAINTTYPE: ConstraintType was invalid or not supported by the provider
TESTC(DBCONSTRAINTTYPE_UNIQUE != pConstraintDesc->ConstraintType);
TESTC(DBCONSTRAINTTYPE_PRIMARYKEY != pConstraintDesc->ConstraintType);
TESTC(DBCONSTRAINTTYPE_FOREIGNKEY != pConstraintDesc->ConstraintType);
TESTC(DBCONSTRAINTTYPE_CHECK != pConstraintDesc->ConstraintType);
break;
case DB_E_BADUPDATEDELETERULE:
TESTC(DBCONSTRAINTTYPE_FOREIGNKEY == pConstraintDesc->ConstraintType);
break;
case DB_E_BADMATCHTYPE:
break;
case DB_E_BADDEFERRABILITY:
break;
case DB_E_BADCONSTRAINTFORM:
if (!( DBCONSTRAINTTYPE_FOREIGNKEY != pConstraintDesc->ConstraintType
&& (0 < pConstraintDesc->cForeignKeyColumns || NULL != pConstraintDesc->pReferencedTableID)
|| DBCONSTRAINTTYPE_CHECK == pConstraintDesc->ConstraintType && NULL == pConstraintDesc->pwszConstraintText
|| DBCONSTRAINTTYPE_CHECK == pConstraintDesc->ConstraintType && 0 != pConstraintDesc->cColumns
|| DBCONSTRAINTTYPE_CHECK != pConstraintDesc->ConstraintType && NULL != pConstraintDesc->pwszConstraintText
|| DBCONSTRAINTTYPE_FOREIGNKEY == pConstraintDesc->ConstraintType && 0 == pConstraintDesc->cForeignKeyColumns
|| ( DBCONSTRAINTTYPE_FOREIGNKEY == pConstraintDesc->ConstraintType
|| DBCONSTRAINTTYPE_PRIMARYKEY == pConstraintDesc->ConstraintType
|| DBCONSTRAINTTYPE_UNIQUE == pConstraintDesc->ConstraintType) && 0 == pConstraintDesc->cColumns
|| DBCONSTRAINTTYPE_FOREIGNKEY == pConstraintDesc->ConstraintType && NULL == pConstraintDesc->pReferencedTableID
))
{
// the only good alternative is that the columns in the referenced table and
// and the ones in the base table have different types
TESTC(fDifferentColTypesInFK);
}
// Note: the case when the column types of corresponding cols do not match in a FK is missing!
break;
case DB_E_NOCOLUMN:
// check that one of the columns referred does not exist in the table
// (either col in the base table or col in the referenced table for FK)
break;
case DB_E_NOTABLE:
// pReferencedTableID (for foreign keys) or pTableID does not exist
break;
case DB_E_TABLEINUSE:
case DB_SEC_E_PERMISSIONDENIED:
case DB_E_SCHEMAVIOLATION:
case XACT_E_XTIONEXISTS:
break;
case E_FAIL:
// this code is legal; caller should catch it if there
// is a more meaningful return value
break;
default:
TESTC(FALSE);
};
CLEANUP:
return hr;
} //TCITableDefinition::AddConstraintAndCheck
//---------------------------------------------------------------------
//
// Drop a constraint to a table using ITableDefinitionWithConstraints::DropConstraint and check its deletion
HRESULT TCITableDefinition::DropConstraintAndCheck(
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints, // [in] pointer to the ITableDefinitionWithConstraints interface to be used
DBID *pTableID, // [in] pointer to the input table ID
DBID *pConstraintID // [in] pointer to the DBID of the constraint
)
{
HRESULT hr = E_FAIL;
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_NOCONSTRAINT,
DB_E_BADTABLEID,
DB_E_DROPRESTRICTED,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
DBORDINAL ulInitConstraints = 0;
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(pITableDefinitionWithConstraints);
TESTC(NULL != pITableDefinitionWithConstraints);
// get all the constraints associated with the table
if (pTableID && DBKIND_NAME == pTableID->eKind)
{
CHECK(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
ulInitConstraints = Constraints.GetConstrNo();
}
else
{
CHECK(Constraints.GetConstraints(NULL, NULL, NULL, NULL, NULL, NULL), S_OK);
}
// drop the constraint
hr = pITableDefinitionWithConstraints->DropConstraint(pTableID, pConstraintID);
// check that the result is one of the expected results
COMPARE(CheckResult(hr, cValidHRes, rgValidHRes), TRUE);
if (FAILED(hr))
{
CHECK(Constraints.AreConstraintsPreserved(), S_OK);
}
else
{
// check that the constraint was dropped
if (NULL != pTableID && DBKIND_NAME == pTableID->eKind)
{
CConstraints NewConstraints(pITableDefinitionWithConstraints);
CHECK(NewConstraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK);
COMPARE(NULL == NewConstraints[pConstraintID], TRUE);
COMPARE(ulInitConstraints-1, NewConstraints.GetConstrNo());
CHECK(Constraints.CheckIncludedConstraints(NewConstraints.GetConstrNo(),
NewConstraints.GetConstraints()), S_OK);
}
}
CLEANUP:
return hr;
} //TCITableDefinition::DropConstraintAndCheck
//---------------------------------------------------------------------
//
// @member Create the table using ITableDefinition::CreateTable,
// check its creation then drops the table and releases the rowset interface
//---------------------------------------------------------------------
HRESULT TCITableDefinition::CCNDropTable(
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
BOOL fNullPPTableID/*=FALSE*/ // [in] if TRUE ppTableID will be NULL
)
{
HRESULT hr;
BOOL fExists;
DBID *pNewTableID = NULL;
DBID *pOutTableID = NULL; // [out] returned table ID
DBID **ppTableID = fNullPPTableID? NULL: &pOutTableID;
IUnknown *pRowset = NULL; // [out] pointer to outer interface
CTable *pTable = new CTable(m_pITableDefinition, (LPWSTR)gwszModuleName);
hr = CreateAndCheckTable(m_pITableDefinition, NULL, pTableID, cColumnDescs, rgColumnDescs, riid,
cPropertySets, rgPropertySets, ppTableID, &pRowset);
SAFE_RELEASE(pRowset);
pNewTableID = (ppTableID)? *ppTableID: pTableID;
if ( pNewTableID
&& DB_E_NOTABLE != hr
&& DB_E_DUPLICATETABLEID != hr
&& CHECK(pTable->DoesTableExist(pNewTableID, &fExists), S_OK)
&& fExists)
CHECK(m_pITableDefinition->DropTable(pNewTableID), S_OK);
delete pTable;
ReleaseDBID(pOutTableID);
return hr;
} //TCITableDefinition::CCNDropTable
//--------------------------------------------------------------------------
//
// @cmember Check whether the columns were properly created
// The columns of the m_pTable are checked against the column descriptor array <nl>
// returned by ITableDefinition::CreateTable method.
// RETURNS
// TRUE - everything is created ok
// FALSE - errors
//--------------------------------------------------------------------------
BOOL TCITableDefinition::AreColumnsCreatedOK(
DBCOLUMNDESC *rgOutColumnDesc, // [in] the aray returned by ITableDefinition::CreateTable
DBORDINAL cColumnDesc, // [in] the size of the arrays
DBID *pTableID/*=NULL*/, // [in] Table ID
IUnknown *pIUnknown/*=NULL*/ // [in] pointer to a rowset interface on the table
)
{
DBORDINAL cCDFromTable;
BOOL fTestRes = TRUE;
DBCOLUMNDESC *rgCDFromTable = NULL;
ULONG i;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the descriptions of the columns in the table with DBID == m_pTable->GetTableID()
// the list of columns are stored in m_pTable->m_colList
GetColumnDescOnTable(pTableID? pTableID: &m_pTable->GetTableID(),
&rgCDFromTable, &cCDFromTable);
if (cColumnDesc != cCDFromTable)
{
odtLog << "the number of columns asked and created does not fit";
fTestRes = FALSE;
goto CLEANUP;
}
for (i=0; i<cColumnDesc; i++)
{
fTestRes = fTestRes && CompareColumnDesc(&rgOutColumnDesc[i], &rgCDFromTable[i]);
}
CLEANUP:
ReleaseColumnDesc(rgCDFromTable, cCDFromTable);
delete pTable;
return fTestRes;
} //TCITableDefinition::AreColumnsCreatedOK
//--------------------------------------------------------------------
//
// @member Check properties on rowseet and table
// returns TRUE if the prop set is set correctly
// FALSE otherwise
//--------------------------------------------------------------------
BOOL TCITableDefinition::CheckRwstTblPropStatus(
ULONG cPropSets, // [in] the size of the propset array
DBPROPSET *rgPropSets, // [in] propset array
HRESULT hr // [in] the result of the previous op
)
{
GUID guidExpectedPS;
ULONG cPropSet;
ULONG cProp;
BOOL fRes = TRUE;
if (!rgPropSets)
return TRUE;
for (cPropSet = 0; cPropSet < cPropSets; cPropSet++)
{
if (!rgPropSets[cPropSet].rgProperties)
continue;
guidExpectedPS = rgPropSets[cPropSet].guidPropertySet == DBPROPSET_ROWSET? DBPROPSET_ROWSET: DBPROPSET_TABLE;
for (cProp = 0; cProp < rgPropSets[cPropSet].cProperties; cProp++)
{
fRes = fRes && CheckPropertyStatus(rgPropSets[cPropSet].guidPropertySet, guidExpectedPS,
&rgPropSets[cPropSet].rgProperties[cProp], hr);
}
}
return fRes;
} //TCITableDefinition::CheckRwstTblPropStatus
//--------------------------------------------------------------------------
//
// @cmember Check whether the property sets asked for rowset was preserved
// all the data should be inside, the only thing that is allowed to be modified <nl>
// is the property status
//--------------------------------------------------------------------------
BOOL TCITableDefinition::IsRowsetPropSetPreserved
(
DBPROPSET *rgInPropertySets, // the array passed to ITableDefinition::CreateTable
DBPROPSET *rgOutPropertySets, // the aray returned by ITableDefinition::CreateTable
ULONG cPropertySets // the size of the arrays
)
{
ULONG ps, pc;
if (NULL == rgInPropertySets)
return TRUE;
for (ps=0; ps<cPropertySets; ps++)
{
// compare the props in that prop set
if (!CHECK(rgInPropertySets[ps].guidPropertySet == rgOutPropertySets[ps].guidPropertySet, TRUE))
return FALSE;
if (!CHECK(rgInPropertySets[ps].cProperties == rgOutPropertySets[ps].cProperties, TRUE))
return FALSE;
if (NULL == rgInPropertySets[ps].rgProperties)
continue;
for (pc=0; pc<rgInPropertySets[ps].cProperties; pc++)
{
if (!CHECK(rgInPropertySets[ps].rgProperties[pc].dwPropertyID ==
rgOutPropertySets[ps].rgProperties[pc].dwPropertyID, TRUE))
return FALSE;
if (!CHECK(rgInPropertySets[ps].rgProperties[pc].dwOptions ==
rgOutPropertySets[ps].rgProperties[pc].dwOptions, TRUE))
return FALSE;
// use NULL for DSO interface
if (!COMPARE(CompareDBID(rgInPropertySets[ps].rgProperties[pc].colid,
rgOutPropertySets[ps].rgProperties[pc].colid,
NULL), TRUE))
return FALSE;
if (!COMPARE(CompareVariant(&rgInPropertySets[ps].rgProperties[pc].vValue,
&rgOutPropertySets[ps].rgProperties[pc].vValue), TRUE))
return FALSE;
}
}
return TRUE;
} //TCITableDefinition::IsRowsetPropSetPreserved
//--------------------------------------------------------------------------
//
// @cmember Check whether the rowset properties were properly created
// The rowset properties of the m_pTable are checked against the property set<nl>
// returned by ITableDefinition::CreateTable method.
//--------------------------------------------------------------------------
BOOL TCITableDefinition::IsRowsetPropSetCreatedOK
(
DBPROPSET *rgOutPropertySets, // the aray returned by ITableDefinition::CreateTable
ULONG cPropertySets, // the size of the arrays
IUnknown *pIUnknown // pointer to the rowset interface
)
{
IRowsetInfo *pIRowsetInfo = NULL;
DBPROPIDSET *rgPropIDSet = NULL;
DBPROPSET *rgPropertySets = NULL;
ULONG n;
BOOL fTestRes = TEST_PASS;
DBPROPSTATUS ulStatus;
DBPROPOPTIONS ulOption;
DBPROPID ulPropID;
BOOL fSupported;
BOOL fSettable;
VARIANT *pvValue;
if (!pIUnknown || 0 == cPropertySets || !rgOutPropertySets)
return TRUE;
rgPropIDSet = (DBPROPIDSET*) PROVIDER_ALLOC(sizeof(DBPROPIDSET)*cPropertySets);
for (n=0; n<cPropertySets; n++)
{
// get propID in the property set
rgPropIDSet[n].guidPropertySet = rgOutPropertySets[n].guidPropertySet;
rgPropIDSet[n].cPropertyIDs = rgOutPropertySets[n].cProperties;
if (0 == rgOutPropertySets[n].rgProperties)
{
rgPropIDSet[n].rgPropertyIDs = NULL;
continue;
}
else
SAFE_ALLOC(rgPropIDSet[n].rgPropertyIDs, DBPROPID, rgOutPropertySets[n].cProperties);
for (ULONG i=0; i<rgOutPropertySets[n].cProperties; i++)
{
rgPropIDSet[n].rgPropertyIDs[i] = rgOutPropertySets[n].rgProperties[i].dwPropertyID;
}
}
// get the properties of the rowset
if (!VerifyInterface(pIUnknown, IID_IRowsetInfo, ROWSET_INTERFACE, (IUnknown**)&pIRowsetInfo))
{
fTestRes = TEST_FAIL;
goto CLEANUP;
}
else
{
m_hr = pIRowsetInfo->GetProperties(cPropertySets, rgPropIDSet, &n, &rgPropertySets);
ASSERT(n==cPropertySets);
}
if (NULL == rgPropertySets)
{
fTestRes = TEST_FAIL;
goto CLEANUP;
}
// check the properties
for (n=0; n<cPropertySets; n++)
{
// get propID in the property set
if (DBPROPSET_TABLE == rgOutPropertySets[n].guidPropertySet)
continue;
if (0 == rgOutPropertySets[n].cProperties)
continue;
if (rgPropertySets[n].cProperties != rgOutPropertySets[n].cProperties)
fTestRes = TEST_FAIL;
if (NULL == rgOutPropertySets[n].rgProperties)
continue;
if (NULL == rgPropertySets[n].rgProperties)
{
fTestRes = TEST_FAIL;
continue;
}
// check dbpropstatus
if (!CHECK(DBPROPSET_ROWSET == rgOutPropertySets[n].guidPropertySet, TRUE))
{
for (ULONG i=0; i<rgOutPropertySets[n].cProperties; i++)
if (!COMPARE(rgOutPropertySets[n].rgProperties[i].dwStatus, DBPROPSTATUS_NOTSUPPORTED))
fTestRes = TEST_FAIL;
continue;
}
for (ULONG i=0; i<rgOutPropertySets[n].cProperties; i++)
{
ulPropID = rgOutPropertySets[n].rgProperties[i].dwPropertyID;
ulOption = rgOutPropertySets[n].rgProperties[i].dwStatus;
ulStatus = rgOutPropertySets[n].rgProperties[i].dwOptions;
fSupported = SupportedProperty(ulPropID, DBPROPSET_ROWSET);
fSettable = SettableProperty(ulPropID, DBPROPSET_ROWSET);
pvValue = &rgOutPropertySets[n].rgProperties[i].vValue;
if (!fSupported)
{
fTestRes = DBPROPSTATUS_NOTSUPPORTED == ulStatus? fTestRes : TEST_FAIL;
continue;
}
// property is supported => cannot be sure that setting a prop will fail
// if is settable, the prop should succeed, unless a bad value is tried
if (DBPROPSTATUS_OK == ulStatus)
{
if (ulPropID != rgOutPropertySets[n].rgProperties[i].dwPropertyID)
fTestRes = TEST_FAIL;
if (!CompareVariant(pvValue, &rgOutPropertySets[n].rgProperties[i].vValue))
{
fTestRes = TEST_FAIL;
odtLog << "Rowset property values missmatch for property propID("
<< rgOutPropertySets[n].rgProperties[i].dwPropertyID << ")\n";
}
}
switch (ulStatus)
{
case DBPROPSTATUS_CONFLICTING:
fTestRes = (DBPROPOPTIONS_OPTIONAL == ulOption || DBPROPOPTIONS_REQUIRED == ulOption)
&& pvValue->vt == GetPropInfoType(ulPropID, DBPROPSET_ROWSET)? fTestRes : TEST_FAIL;
break;
case DBPROPSTATUS_NOTSET:
fTestRes = COMPARE(ulOption, DBPROPOPTIONS_OPTIONAL)
&& pvValue->vt == GetPropInfoType(ulPropID, DBPROPSET_ROWSET)? fTestRes : TEST_FAIL;
break;
case DBPROPSTATUS_BADOPTION:
fTestRes = (DBPROPOPTIONS_OPTIONAL != ulOption)
&& (DBPROPOPTIONS_REQUIRED)? fTestRes : TEST_FAIL;
break;
case DBPROPSTATUS_NOTSETTABLE:
fTestRes = !fSettable? fTestRes: TEST_FAIL;
break;
case DBPROPSTATUS_BADVALUE:
fTestRes = (VT_EMPTY != pvValue->vt)
&& (pvValue->vt != GetPropInfoType(ulPropID, DBPROPSET_ROWSET))
? fTestRes : TEST_FAIL;
}
}
}
CLEANUP:
SAFE_RELEASE(pIRowsetInfo);
for (n=0; n<cPropertySets; n++)
PROVIDER_FREE(rgPropIDSet[n].rgPropertyIDs);
PROVIDER_FREE(rgPropIDSet);
FreeProperties( &cPropertySets, &rgPropertySets);
return fTestRes;
} //TCITableDefinition::IsRowsetPropSetCreatedOK
//--------------------------------------------------------------------------
//
// @cmember Creates a table with a column of each provider type and returns a rowset
// to the new created table. The rowset is created with the property required and it
// is tested
//--------------------------------------------------------------------------
int TCITableDefinition::CreateWithOneRowsetProps
(
DBPROPID PropID, // Property ID
DBTYPE DBType, // type of property value
LPVOID Value, // value to be set
struct _GUID *pRIID // interface asked on rowset
)
{
DBTYPE rgDBTypes[] = {DBType};
LPVOID rgValues[] = {Value};
DBPROPOPTIONS rgOptions[] = {DBPROPOPTIONS_OPTIONAL};
DBPROPOPTIONS rgOptions2[] = {DBPROPOPTIONS_REQUIRED};
return CreateWithRowsetProps(1, &PropID, rgDBTypes, rgValues, rgOptions, pRIID)
&& CreateWithRowsetProps(1, &PropID, rgDBTypes, rgValues, rgOptions2, pRIID);
} //TCITableDefinition::CreateWithOneRowsetProps
//--------------------------------------------------------------------------
//
// @cmember Creates a table with a column of each provider type and returns a rowset
// to the new created table. The rowset is created with the properties required and it
// is tested
//--------------------------------------------------------------------------
BOOL TCITableDefinition::CreateWithRowsetProps
(
ULONG nProperties, // number of the properties to be set
DBPROPID *rgPropID, // array with the propIDs
DBTYPE *rgDBType, // type of property values
LPVOID *rgValue, // values to be set
DBPROPOPTIONS *rgOptions, // options of properties
struct _GUID *pRIID // interface asked on rowset
)
{
BOOL fRes = FALSE;
DBPROPSET *rgPropertySets = NULL;
ULONG n, cPropertySets = 0;
HRESULT hr = E_FAIL;
CCol col;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fExists;
DBID *pTableID = NULL;
IUnknown *pRowset = NULL; // [out] pointer to outer interface
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
TESTC(nProperties);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
for (n=0; n<nProperties; n++)
{
SetProperty(&rgPropertySets, &cPropertySets, rgPropID[n],
rgDBType[n], rgValue[n], rgOptions[n], DB_NULLID, DBPROPSET_ROWSET);
}
hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc, *pRIID,
cPropertySets, rgPropertySets, &pTableID, &pRowset);
SAFE_RELEASE(pRowset);
if ( pTableID
&& DB_E_NOTABLE != hr
&& DB_E_DUPLICATETABLEID != hr
&& CHECK(pTable->DoesTableExist(pTableID, &fExists), S_OK)
&& fExists)
CHECK(m_pITableDefinition->DropTable(pTableID), S_OK);
delete pTable;
ReleaseDBID(pTableID);
if (FAILED(hr))
{
odtLog << "Could not create a table with a specified property set.\n";
if ( (1 == nProperties)
&& (DBPROPSTATUS_OK != rgPropertySets[0].rgProperties[0].dwStatus)
&& ( (DBPROPOPTIONS_REQUIRED == rgPropertySets[0].rgProperties[0].dwStatus)
&& !CHECK(hr, DB_E_ERRORSOCCURRED)))
{
odtLog << "wrong value for dwStatus in rowset property";
goto CLEANUP;
}
}
else
// check the creation of the rowset
if ( (1 == nProperties)
&& ( ( (DBPROPSTATUS_OK == rgPropertySets[0].rgProperties[0].dwStatus)
&& !CHECK(hr, S_OK))
|| ( (DBPROPSTATUS_OK != rgPropertySets[0].rgProperties[0].dwStatus)
&& !CHECK(hr, DB_S_ERRORSOCCURRED))))
{
odtLog << "wrong value for dwStatus in rowset property";
goto CLEANUP;
}
fRes = TRUE;
CLEANUP:
FreeProperties( &cPropertySets, &rgPropertySets);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fRes;
} //TCITableDefinition::CreateWithRowsetProps
//--------------------------------------------------------------------------
//
// creates a table with not nullable column
//--------------------------------------------------------------------------
HRESULT TCITableDefinition::CreateTableWithNoNullableColumns(
CTable *pTable, // @param [IN] pointer to CTable
DBCOUNTITEM ulRowCount, // @parm [IN] # of Rows to insert into table, 1 based
DBORDINAL ulIndex /*=0*/, // @parm [IN] Column Number of index, 1 based (Default=1)
WCHAR *pwszTableName/*=NULL*/, // @parm [IN] TableName, if NULL call MakeTableName() (Default=NULL)
EVALUE eValue/*=PRIMARY*/, // @parm [IN] Insert PRIMARY or SECONDARY data (Default=PRIMARY)
BOOL fFirstUpdateable/*=FALSE*/ // @parm [IN] TRUE means first column will be autoinc (Default=FALSE)
)
{
HRESULT hr = E_FAIL;
// customize the table so that no nullable columns is added
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBORDINAL indexCol;
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
for (indexCol = 0; indexCol < m_cColumnDesc; indexCol++)
{
SetProperty(&rgNewColumnDesc[indexCol].rgPropertySets, &rgNewColumnDesc[indexCol].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
}
// by setting DBCOLUMNDESC, all nullable type column are created as nullable
pTable->SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
pTable->SetBuildColumnDesc(FALSE);
TESTC_(pTable->CreateTable(ulRowCount, ulIndex, pwszTableName, eValue, fFirstUpdateable), S_OK);
pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition, pTable->GetTableName());
hr = S_OK;
CLEANUP:
return hr;
} //TCITableDefinition::CreateTableWithNoNullableColumns
HRESULT TCITableDefinition::AddUniqueConstraint(
CTable *pTable,
DBORDINAL ulCol,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
return AddKeyConstraint(DBCONSTRAINTTYPE_UNIQUE, pTable, 1, &ulCol, Deferrability);
} //TCITableDefinition::AddUniqueConstraint
HRESULT TCITableDefinition::AddUniqueConstraint(
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
return AddKeyConstraint(DBCONSTRAINTTYPE_UNIQUE, pTable, cCol, rgCol, Deferrability);
} //TCITableDefinition::AddUniqueConstraint
HRESULT TCITableDefinition::AddPrimaryKeyConstraint(
CTable *pTable,
DBORDINAL ulCol,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
return AddKeyConstraint(DBCONSTRAINTTYPE_PRIMARYKEY, pTable, 1, &ulCol, Deferrability);
} //TCITableDefinition::AddPrimaryKeyConstraint
HRESULT TCITableDefinition::AddPrimaryKeyConstraint(
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
return AddKeyConstraint(DBCONSTRAINTTYPE_PRIMARYKEY, pTable, cCol, rgCol, Deferrability);
} //TCITableDefinition::AddPrimaryKeyConstraint
HRESULT TCITableDefinition::AddKeyConstraint(
DBCONSTRAINTTYPE ConstraintType,
CTable *pTable,
DBORDINAL cCol,
DBORDINAL *rgCol,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
HRESULT hr = E_FAIL;
CCol col;
CKeyConstraint cons(ConstraintType);
DBORDINAL ulRow;
TESTC(NULL != m_pITDWC);
TESTC(NULL != pTable);
TESTC(0 == cCol || NULL != rgCol);
TESTC(DBCONSTRAINTTYPE_UNIQUE == ConstraintType || DBCONSTRAINTTYPE_PRIMARYKEY == ConstraintType);
TESTC_(cons.SetConstraint(pTable, cCol, rgCol, Deferrability), S_OK);
TESTC_(pTable->GetColInfo(rgCol[0], col), S_OK);
hr = AddConstraintAndCheck(m_pITDWC, &pTable->GetTableID(), cons);
// check that inserting a row with duplicate key is not accepted
if (SUCCEEDED(hr))
{
ulRow = pTable->GetNextRowNumber();
// check that you can not add a row to the base table (no nulls are inserted, right?)
if (S_OK == pTable->Insert(ulRow))
CHECK(pTable->Insert(ulRow), DB_E_INTEGRITYVIOLATION);
}
CLEANUP:
return hr;
} // TCITableDefinition::AddKeyConstraint
HRESULT TCITableDefinition::AddForeignKeyConstraint(
CTable *pBaseTable,
DBORDINAL cBaseCol,
DBORDINAL *rgBaseCol,
CTable *pReferencedTable,
DBORDINAL cReferencedCol,
DBORDINAL *rgReferencedCol,
DBMATCHTYPE MatchType /*= DBMATCHTYPE_FULL*/,
DBUPDELRULE UpdateRule /*= DBUPDELRULE_NOACTION*/,
DBUPDELRULE DeleteRule /*= DBUPDELRULE_NOACTION*/,
DBDEFERRABILITY Deferrability /*= 0*/
)
{
HRESULT hr = E_FAIL;
CForeignKeyCons cons;
DBORDINAL ulRow;
DBORDINAL index;
DBORDINAL ulMaxCol;
TESTC_(cons.SetConstraint(pBaseTable, cBaseCol, rgBaseCol,
pReferencedTable, cReferencedCol, rgReferencedCol,
MatchType, UpdateRule, DeleteRule, Deferrability), S_OK);
hr = AddConstraintAndCheck(m_pITDWC, &pBaseTable->GetTableID(), cons);
if (S_OK == hr)
{
// find the maximum column of the foreign key
for (index = 1, ulMaxCol = rgBaseCol[0]; index < cBaseCol; index++)
{
ulMaxCol = (ulMaxCol < rgBaseCol[index])? rgBaseCol[index]: ulMaxCol;
}
ulRow = pReferencedTable->GetNextRowNumber();
ulRow = (ulRow <= ulMaxCol)? ulMaxCol + 1: ulRow;
// check that you can not add a row to the base table (no nulls are inserted, right?)
// Note: if there is a NULL column in the foreign key schema this insert
// rightfully succeeds
TEST2C_(pBaseTable->Insert(ulRow), DB_E_INTEGRITYVIOLATION, E_FAIL);
// check that you can add a row to the referenced table
CHECK(pReferencedTable->Insert(ulRow), S_OK);
// check that you can now add a row to the base table
CHECK(pBaseTable->Insert(ulRow), S_OK);
}
CLEANUP:
return hr;
} // TCITableDefinition::AddForeignKeyConstraint
//--------------------------------------------------------------------------
//
// @cmember Termination function
//--------------------------------------------------------------------------
BOOL TCITableDefinition::Terminate()
{
DeleteCriticalSection(&m_CriticalSection);
ULONG nTables;
nTables = GetNoOfTables();
ReleaseColumnDesc(m_rgColumnDesc, m_cColumnDesc);
if (nTables>m_nTables)
odtLog << "Numer of residual tables: " << nTables-m_nTables << "\n";
nResidualTables += nTables-m_nTables;
SAFE_RELEASE(m_pITableDefinition);
SAFE_RELEASE(m_pITDWC);
ReleaseDBSession();
ReleaseDataSourceObject();
m_ColList.RemoveAll();
PROVIDER_FREE(m_pwszInvalidTableChars);
PROVIDER_FREE(m_pwszInvalidColChars);
return(CSessionObject::Terminate());
} //TCITableDefinition::Terminate
// {{ TCW_TC_PROTOTYPE(TCAddColumn)
//*-----------------------------------------------------------------------
//| Test Case: TCAddColumn - Testcase for ITableDefinition::AddColumn
//| Created: 09/10/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddColumn::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
//
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Table doesn't exist => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_1()
{
BOOL fTestRes = TEST_PASS, fExists;
DBID TableID;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TableID.eKind = DBKIND_NAME;
// CTable::MakeTableName() generates a name that doesn't exist in the catalog
m_pTable->MakeTableName(NULL);
TableID.uName.pwszName = m_pTable->GetTableName();
// try to add a column on this table that doesn't exist
if (!CHECK(m_hr = m_pITableDefinition->AddColumn(&TableID, rgColumnDesc, &pColumnID), DB_E_NOTABLE))
fTestRes = TEST_FAIL;
if (!CHECK(m_pTable->DoesTableExist(&TableID, &fExists), S_OK) || fExists)
{
odtLog << "Table " << TableID.uName.pwszName << " was added by AddColumn!\n";
fTestRes = TEST_FAIL;
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc The table is in use => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_2()
{
TBEGIN
DBID *pColumnID = NULL;
IRowset *pIRowset = NULL;
IRowsetChange *pIRowsetChange = NULL;
IRowsetChange *pIRowsetChange2 = NULL;
HRESULT hr;
HACCESSOR hAccessor = NULL;
BYTE *pData = NULL;
DBCOUNTITEM cBindings = 0;
DBBINDING *rgBindings = NULL;
const DBORDINAL cColsToBind = 1;
LONG_PTR rgColsToBind[cColsToBind];
HROW *rghRow = NULL;
DBCOUNTITEM cRowsObtained = 0;
DBPROPSET rgPropSets[1];
DBPROP rgProperties[1];
DBLENGTH ulRowSize;
DBCOUNTITEM nRowNo;
DBCOUNTITEM nRowsInTable = 0;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
const DBCOUNTITEM nRowsToInsert = 10;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
// ask for a IRowsetChange interface
m_pTable->SetRowset((IUnknown**)&pIRowsetChange);
if (SettableProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET))
m_pTable->SetRIID((struct _GUID*)&IID_IRowsetChange);
else
m_pTable->SetRIID((struct _GUID*)&IID_IRowset);
// Set properties
FILL_PROP_SET(rgPropSets[0], 1, rgProperties, DBPROPSET_ROWSET);
FILL_PROP(rgProperties[0], DBPROP_OWNINSERT, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
m_pTable->SetPropertySets(rgPropSets, NUMELEM(rgPropSets));
// creates the table and populates it, using the returned pIRowsetChange
TESTC_(hr = m_pTable->CreateTable(0, 0), S_OK);
// check whether iRowsetChange is available
VerifyInterface(pIRowsetChange, IID_IRowsetChange, ROWSET_INTERFACE, (IUnknown**)&pIRowsetChange2);
if (pIRowsetChange2)
{
for (nRowNo = 0; nRowNo < nRowsToInsert; nRowNo++)
{
if (S_OK == Insert(0, (IUnknown*)pIRowsetChange))
nRowsInTable++;
}
}
TESTC(VerifyInterface(pIRowsetChange, IID_IRowset, ROWSET_INTERFACE, (IUnknown**)&pIRowset));
// get a row
if (0 < nRowsInTable)
{
m_hr = pIRowset->GetNextRows(0, 0, // hChapter & lRowsOffset
1, // number of rows to be retrieved
&cRowsObtained, //number of rows actually get
&rghRow // array of handlers to rows
);
if (!CHECK(m_hr, S_OK))
{
odtLog << "insuccess on initial IRowset::GetNextRows\n";
m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL);
}
// test the return value of IRowset::RestartPosition
CHECK(m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL), S_OK);
PROVIDER_FREE(rghRow);
cRowsObtained = 0;
}
else
odtLog << "Could not insert any row in the table\n";
// check if a column can be added, on the table in use (look for S_OK or DB_E_TABLEINUSE)
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID);
if (hr == S_OK)
{
odtLog << "Column was added while a rowset was still open on table.\n";
if (1 > nRowsInTable)
goto CLEANUP;
// see how it reacts to RestartPosition and if the new column can be read
hr = pIRowset->RestartPosition(0); // a non-chaptered rowset
if (hr == DB_S_COLUMNSCHANGED)
{
odtLog << "DB_S_COLUMNSCHANGED returned on pIRowset->RestartPosition\n";
// get the value of the new column in the first row
//Get an accessor with all the writeable columns
rgColsToBind[0] = (LONG_PTR)cColumnDesc-1;
if (!CHECK(hr = GetAccessorAndBindings(
pIRowset, // pIUnknRowsetObject
DBACCESSOR_ROWDATA, // accessor flags
&hAccessor, &rgBindings, &cBindings, // accessor handler, array and number of bindings created
&ulRowSize, // [OUT] row size
DBPART_VALUE |DBPART_STATUS |DBPART_LENGTH, // types of bindings to do
USE_COLS_TO_BIND_ARRAY, // eColsByRef specifies that cols to be bind
// are given as an array
FORWARD, // eBindingOrder
NO_COLS_BY_REF, // eColsByRef
NULL, NULL,
NULL, DBTYPE_EMPTY, // ppStringsBufferOut & dwModifier
1, rgColsToBind // size and array of cols to be bind
), S_OK))
{
odtLog << "problems getting accessor and bindings\n";
}
// alloc memory for the row data
SAFE_ALLOC(pData, BYTE, ulRowSize);
// get the rowset window
m_hr = pIRowset->GetNextRows(0, 0, // hChapter & lRowsOffset
1, // number of rows to be retrieved
&cRowsObtained, //number of rows actually get
&rghRow // array of handlers to rows
);
if (S_OK != m_hr || !COMPARE(1 == cRowsObtained, TRUE))
{
odtLog << "after RestartPosition, could not get the rows\n";
CHECK(m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL), S_OK);
goto CLEANUP;
}
// read data
CHECK(m_hr = pIRowset->GetData(rghRow[0], hAccessor, pData), S_OK);
if ((S_OK != m_hr) ||
((DBSTATUS_S_OK != ((DATA*)pData)->sStatus) &&
!COMPARE(DBSTATUS_S_ISNULL == ((DATA*)pData)->sStatus, TRUE) ))
{
odtLog << "can't get the data from the newly created column\n";
}
else
odtLog << "data read!\n";
CHECK(m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL), S_OK);
}
}
else
{
odtLog << "DB_E_TABLEINUSE was returned when a column was to be added on a table whith an open rowset.\n";
CHECK(hr, DB_E_TABLEINUSE);
}
CLEANUP:
m_pTable->SetRowset(NULL);
SAFE_RELEASE(pIRowsetChange2);
SAFE_RELEASE(pIRowset);
SAFE_FREE(pData);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
m_pTable->SetNoOfPropertySets(0);
m_pTable->SetPropertySets(NULL);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
FreeAccessorBindings(cBindings, rgBindings);
SAFE_FREE(pData);
SAFE_FREE(rghRow);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc *pTableID = DB_NULLID => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_3()
{
BOOL fTestRes = TEST_PASS;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// try to add a column from this table that doesn't exist
if (!CHECK(m_pITableDefinition->AddColumn((DBID*)&DB_NULLID, rgColumnDesc, &pColumnID), DB_E_NOTABLE))
fTestRes = TEST_FAIL;
ReleaseDBID(pColumnID);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pTableID = NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_4()
{
BOOL fTestRes = TEST_PASS;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// try to add a column from this table that doesn't exist
if (!CHECK(m_hr = m_pITableDefinition->AddColumn(NULL, rgColumnDesc, &pColumnID), E_INVALIDARG))
fTestRes = TEST_FAIL;
ReleaseDBID(pColumnID);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Maximum length for table name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_5()
{
TBEGIN
DBID TableID;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
PRVTRACE(L"***TCADDColumn::Variation_5(): TableName=%s, len=%d\n",
TableID.uName.pwszName, wcslen(TableID.uName.pwszName));
TESTC_(m_pTable->CreateTable(0, 0, TableID.uName.pwszName), S_OK);
// try to add a column to this maximum length name table
// prepare the column to be added
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1], &pColumnID), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(&TableID, FALSE); // don't want to release the pointer, just the container
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc the table name is 1 char too long => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_6()
{
TBEGIN
DBID TableID;
DBID *pColumnID = NULL;
WCHAR *pwszTableName;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
GetLiteralInfo();
TableID.uName.pwszName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
pwszTableName = BuildValidName(m_cMaxTableName+1, m_pTable->GetTableName());
// prepare arguments for table creation
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
PRVTRACE(L"***TCADDColumn::Variation_6(): TableName=%s, len=%d\n", TableID.uName.pwszName,
wcslen(TableID.uName.pwszName));
TESTC_(m_pTable->CreateTable(0, 0, TableID.uName.pwszName), S_OK);
// try to add a column, spec the table name plus a char as a table name
PROVIDER_FREE(TableID.uName.pwszName);
TableID.uName.pwszName = pwszTableName;
TESTC_(AddColumnAndCheck(&TableID, &rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_NOTABLE);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc invalid table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_7()
{
BOOL fTestRes = TEST_PASS;
DBID TableID;
DBID *pColumnID = NULL;
size_t m, n;
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
m = min(m_cMaxTableName, n=5+wcslen(m_pTable->GetTableName()));
TableID.uName.pwszName = BuildInvalidName(m, m_pTable->GetTableName(), m_pwszInvalidTableChars);
PRVTRACE(L"***TCADDColumn::Variation_7(): TableName=%s, len=%d\n", TableID.uName.pwszName,
wcslen(TableID.uName.pwszName));
if (!CHECK(m_hr = m_pITableDefinition->AddColumn(&TableID, &rgColumnDesc[0], &pColumnID), DB_E_NOTABLE))
fTestRes = TEST_FAIL;
ReleaseDBID(pColumnID);
ReleaseDBID(&TableID, FALSE);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc pColumnDesc->dbcid = DB_NULLID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_8()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a DB_NULLID colid to this table
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
memcpy(&rgColumnDesc[cColumnDesc-1].dbcid, (DBID*)&DB_NULLID, sizeof(DBID));
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), DB_E_BADCOLUMNID);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Column name pointer is NULL => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_9()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a NULL value for name pointer
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = NULL;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc column name is an empty string => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_10()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
// create a table with cColumnDesc-1 columns
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a NULL value for name pointer
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = wcsDuplicate(L"");
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Maximum length of column name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_11()
{
TBEGIN
DBID *pColumnID = NULL;
WCHAR *pwszName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->MakeTableName(NULL);
pwszName = wcsDuplicate(m_pTable->GetTableName());
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a maximum size for column name
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszName);
odtLog << "A maximum length column name: " << rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName <<
", length=" << wcslen(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName) << "\n";
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
PROVIDER_FREE(pwszName);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc 1-char-too-long column name => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_12()
{
TBEGIN
WCHAR *pwszName = NULL;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->MakeTableName(NULL);
pwszName = wcsDuplicate(m_pTable->GetTableName());
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a name too long
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = BuildValidName(m_cMaxColName+1, pwszName);
odtLog << "A 1 char too long column name: " << rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName <<
", length=" << wcslen(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName) << "\n";
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
SAFE_FREE(pwszName);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Add a column for each provider type, maximum column size => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_13()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i;
DBCOLUMNDESC *pColumnDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
DuplicateColumnDesc(rgColumnDesc, 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName);
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"FirstColumn");
// for each type in DBCOLUMNDESC, add a column with maximum column size
SetMaximumColSize(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(pColumnDesc, 1);
for (i=0; i<cColumnDesc; i++)
{
// create a table with a single column, equal to the first one in the row
CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK);
if (FAILED(m_hr))
continue;
// try to add a column from rgColumnDesc[i]
odtLog << "column name:" << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type:" << rgColumnDesc[i].pwszTypeName << "\n";
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i],
&pColumnID), S_OK);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Add a column for each known type; ulColumnsize == 0 => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_14()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i;
DBCOLUMNDESC *pColumnDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
DuplicateColumnDesc(rgColumnDesc, 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName);
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"FirstColumn");
SetZeroColSize(rgColumnDesc, cColumnDesc);
// for each type in DBCOLUMNDESC, add a column with maximum column size
m_pTable->SetColumnDesc(NULL);
m_pTable->SetColumnDesc(pColumnDesc, 1);
m_pTable->SetBuildColumnDesc(FALSE);
for (i=0; i<cColumnDesc; i++)
{
// create a table with a single column, equal to the first one in the row
CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK);
if (FAILED(m_hr))
continue;
// try to add a column from rgColumnDesc[i]
odtLog << "column name:" << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type:" << rgColumnDesc[i].pwszTypeName << "\n";
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i],
&pColumnID), S_OK);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//--------------------------------------------------------------------
// @mfunc Add a column for each provider type (table is populated) => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_15()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i;
DBCOLUMNDESC *pColumnDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
DuplicateColumnDesc(rgColumnDesc, 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName);
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"FirstColumn");
m_pTable->SetColumnDesc(NULL);
m_pTable->SetColumnDesc(pColumnDesc, 1);
m_pTable->SetBuildColumnDesc(FALSE);
for (i=0; i<cColumnDesc; i++)
{
// try to add a column from rgColumnDesc[i]
odtLog << "column name:" << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type:" << rgColumnDesc[i].pwszTypeName << "\n";
// create a popoulated table
if (!CHECK(m_pTable->CreateTable(10, 0), S_OK))
continue;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i],
&pColumnID), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Precision testing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_16()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i;
WCHAR *pwszColumnName = NULL;
BYTE precision, p[6];
ULONG nmax = 6;
WCHAR *prefix[]={L"zero", L"one", L"half", L"max", L"big", L"extra"};
HRESULT hres;
DBCOLUMNDESC *rgColDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
DuplicateColumnDesc(rgColumnDesc, 1, &rgColDesc);
m_pTable->SetColumnDesc(rgColDesc, 1);
m_pTable->SetBuildColumnDesc(FALSE);
SAFE_FREE(rgColDesc[0].dbcid.uName.pwszName);
rgColDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"initialColumn");
// for each type in DBCOLUMNDESC, add a column with different precision value
for (i=0; i<cColumnDesc; i++)
{
// try to add a column with different precision values
odtLog << "column name:" << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type:" << rgColumnDesc[i].pwszTypeName << "\n";
precision = rgColumnDesc[i].bPrecision; // BuildColumnDesc puts max val in bPrecision!
p[0] = 0;
p[1] = 1;
p[2] = precision/2;
p[3] = precision;
if (precision > 254)
nmax = 4;
p[4] = precision+1;
p[5] = (ULONG)precision+10>255? 255: precision+10;
pwszColumnName = rgColumnDesc[i].dbcid.uName.pwszName;
rgColumnDesc[i].dbcid.uName.pwszName = NULL;
rgColumnDesc[i].bScale = 0;
rgColumnDesc[i].ulColumnSize = 0;
for (ULONG j=0; j<nmax; j++)
{
odtLog << "\t" << p[j];
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// if needed you can limit wcscat with the max length for col size
rgColumnDesc[i].dbcid.uName.pwszName = (WCHAR*) PROVIDER_ALLOC( sizeof(WCHAR) * m_cMaxColName);
wcscpy(rgColumnDesc[i].dbcid.uName.pwszName, prefix[j]);
wcsncat(rgColumnDesc[i].dbcid.uName.pwszName, pwszColumnName, m_cMaxColName-wcslen(prefix[j]));
rgColumnDesc[i].bPrecision = p[j];
hres = S_OK;
if (rgColumnDesc[i].wType == DBTYPE_NUMERIC && ((j>3) || (j==0)) )
hres = DB_E_BADPRECISION;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], &pColumnID), hres);
SAFE_FREE(rgColumnDesc[i].dbcid.uName.pwszName);
rgColumnDesc[i].dbcid.uName.pwszName = NULL;
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
odtLog << "\n";
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Scale testing
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_17()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i;
WCHAR *pwszName;
DBCOLUMNDESC *pColumnDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
DuplicateColumnDesc(rgColumnDesc, 1, &pColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName);
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"Initial_column");
// create a table with a single column, equal to the first one in the row
m_pTable->SetColumnDesc(NULL); // so that m_pTable->rgColumnDesc will not be deallocated next
m_pTable->SetColumnDesc(pColumnDesc, 1);
m_pTable->SetBuildColumnDesc(FALSE);
// for each type in DBCOLUMNDESC, add a column with different precision value
for (i=0; i<cColumnDesc; i++)
{
CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK);
if (!SUCCEEDED(m_hr))
continue;
odtLog << "column name: " << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type: " << rgColumnDesc[i].pwszTypeName << "\n";
if ( rgColumnDesc[i].wType == DBTYPE_NUMERIC
|| rgColumnDesc[i].wType == DBTYPE_DECIMAL
|| rgColumnDesc[i].wType == DBTYPE_VARNUMERIC )
{
const int nScales = 7;
BYTE smax, smin, p[nScales], s[nScales], precision;
ULONG nmax = 1;
WCHAR *prefix[]={L"zero", L"min", L"half", L"max", L"maxpp", L"prec", L"extra_prec"};
HRESULT hres[nScales] = {S_OK, S_OK, S_OK, S_OK, S_OK, S_OK, S_OK};
CCol col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// try to add a column with different scale values
smin = (BYTE)col.GetMinScale();
smax = (BYTE)col.GetMaxScale();
precision = (BYTE)col.GetPrecision();
for (ULONG k=0; k<nScales; p[k++]=precision);
s[0] = 0;
hres[0] = (smin==0)? S_OK: DB_E_BADSCALE;
if (smin > 0)
{
s[1] = smin;
nmax++;
}
s[nmax++] = (smin+smax)/2;
s[nmax++] = smax;
if (smax < 255)
{
s[nmax] = smax+1;
hres[nmax++] = DB_E_BADSCALE;
// check matching the precision
s[nmax] = precision;
hres[nmax] = (precision>smax) ? DB_E_BADSCALE: S_OK;
nmax++;
s[nmax] = p[nmax]+1;
hres[nmax++]= DB_E_BADSCALE;
}
pwszName = rgColumnDesc[i].dbcid.uName.pwszName;
rgColumnDesc[i].dbcid.uName.pwszName = NULL; // protection for inside the loop!
for (ULONG j=0; j<nmax; j++)
{
odtLog << "\t" << s[j];
// if needed you can limit wcscat with the max length for col size
if (rgColumnDesc[i].dbcid.uName.pwszName)
SAFE_FREE(rgColumnDesc[i].dbcid.uName.pwszName);
rgColumnDesc[i].dbcid.uName.pwszName = (WCHAR*) PROVIDER_ALLOC( sizeof(WCHAR) * m_cMaxColName);
wcscpy(rgColumnDesc[i].dbcid.uName.pwszName, prefix[j]);
wcsncat(rgColumnDesc[i].dbcid.uName.pwszName, pwszName, m_cMaxColName-wcslen(prefix[j]));
rgColumnDesc[i].bPrecision = p[j];
rgColumnDesc[i].bScale = s[j];
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], &pColumnID), hres[j]);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
odtLog << "\n";
SAFE_FREE(pwszName);
}
else
{
rgColumnDesc[i].bScale = 128;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], &pColumnID), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
m_pTable->SetNoOfColumnDesc(1);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Invalid value for the property of a column => DB_E_ERRORSOCCURRED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_18()
{
TBEGIN
DBID *pColumnID = NULL;
DBPROPID dwPropID = DBPROP_COL_UNIQUE;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a bad property value (prop of a different type than expected)
SetProperty(&rgColumnDesc[cColumnDesc-1].rgPropertySets,
&rgColumnDesc[cColumnDesc-1].cPropertySets,
dwPropID,
VT_I2, (LPVOID)12,
DBPROPOPTIONS_REQUIRED);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_ERRORSOCCURRED);
TESTC(VerifyPropStatus(rgColumnDesc[cColumnDesc-1].cPropertySets,
rgColumnDesc[cColumnDesc-1].rgPropertySets, dwPropID, DBPROPSET_COLUMN,
DBPROPSTATUS_BADVALUE));
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Non-column property => DBPROPSTATUS_NOTSUPPORTED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_19()
{
TBEGIN
DBID *pColumnID = NULL;
DBPROPID dwPropID = DBPROP_COL_UNIQUE;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a bad property guid (DBPROPSET_INDEX)
SetProperty(
&rgColumnDesc[cColumnDesc-1].rgPropertySets, &rgColumnDesc[cColumnDesc-1].cPropertySets,
dwPropID,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_OPTIONAL, DB_NULLID, DBPROPSET_INDEX);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_S_ERRORSOCCURRED);
TESTC(VerifyPropStatus(rgColumnDesc[cColumnDesc-1].cPropertySets,
rgColumnDesc[cColumnDesc-1].rgPropertySets, dwPropID, DBPROPSET_INDEX, DBPROPSTATUS_NOTSUPPORTED));
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Inexistent property => DBPROPSTATUS_NOTSUPPORTED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_20()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a bad property id
SetProperty(&rgColumnDesc[cColumnDesc-1].rgPropertySets,
&rgColumnDesc[cColumnDesc-1].cPropertySets, 0xffffffff, VT_BOOL, (LPVOID)VARIANT_TRUE);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_S_ERRORSOCCURRED);
TESTC(VerifyPropStatus(rgColumnDesc[cColumnDesc-1].cPropertySets,
rgColumnDesc[cColumnDesc-1].rgPropertySets, 0xffffffff,
DBPROPSET_COLUMN, DBPROPSTATUS_NOTSUPPORTED));
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Bad option => DBPROPSTATUS_BADOPTION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_21()
{
TBEGIN
DBID *pColumnID = NULL;
DBPROPID dwPropID = DBPROP_COL_NULLABLE;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a bad option
SetProperty(&rgColumnDesc[cColumnDesc-1].rgPropertySets, &rgColumnDesc[cColumnDesc-1].cPropertySets,
dwPropID,
VT_BOOL, (LPVOID)VARIANT_TRUE,
0xf0);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_ERRORSOCCURRED);
TESTC(VerifyPropStatus(rgColumnDesc[cColumnDesc-1].cPropertySets,
rgColumnDesc[cColumnDesc-1].rgPropertySets, dwPropID,
DBPROPSET_COLUMN,DBPROPSTATUS_BADOPTION));
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Conflicting property => DBPROPSTATUS_CONFLICTING
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_22()
{
TBEGIN
DBID *pColumnID = NULL;
DBORDINAL i, nCol;
CCol col;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
ULONG nConfStatus = 0;
ULONG nOKStatus = 0;
TESTC_PROVIDER(SettableProperty(DBPROP_COL_PRIMARYKEY, DBPROPSET_COLUMN)
&& SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
nCol = cColumnDesc;
for (i=0; i< cColumnDesc; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
if (col.GetNullable()!=0)
nCol = i;
}
TESTC(nCol < cColumnDesc);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with conflicting properties
PROVIDER_FREE(rgColumnDesc[nCol].dbcid.uName.pwszName);
rgColumnDesc[nCol].dbcid.uName.pwszName = wcsDuplicate(L"MyColumn");
SetProperty(&rgColumnDesc[nCol].rgPropertySets, &rgColumnDesc[nCol].cPropertySets,
DBPROP_COL_PRIMARYKEY, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
SetProperty(&rgColumnDesc[nCol].rgPropertySets, &rgColumnDesc[nCol].cPropertySets,
DBPROP_COL_NULLABLE, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[nCol], &pColumnID), DB_E_ERRORSOCCURRED);
if (DBPROPSTATUS_CONFLICTING == rgColumnDesc[nCol].rgPropertySets[0].rgProperties[0].dwStatus)
nConfStatus++;
else
{
TESTC(DBPROPSTATUS_OK == rgColumnDesc[nCol].rgPropertySets[0].rgProperties[0].dwStatus);
}
if (DBPROPSTATUS_CONFLICTING == rgColumnDesc[nCol].rgPropertySets[0].rgProperties[1].dwStatus)
nConfStatus++;
else
{
TESTC(DBPROPSTATUS_OK == rgColumnDesc[nCol].rgPropertySets[0].rgProperties[1].dwStatus);
}
TESTC(0 < nConfStatus);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//--------------------------------------------------------------------
// @mfunc Bad column ID for a property => ignored
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_23()
{
TBEGIN
DBID *pColumnID = NULL;
DBID colID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBORDINAL cCol;
CCol col;
BOOL fFound = FALSE;
BOOL fExists;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
for (cCol=0; cCol < m_cColumnDesc; cCol++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[cCol]), rgColumnDesc[cCol].wType, &fExists);
fFound = fExists && 1 == col.GetNullable();
break;
}
TESTC_PROVIDER(fFound && SupportedProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN));
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a property that set coldid to smthg different from DB_NULLID
colID.eKind = DBKIND_NAME;
colID.uName.pwszName = wcsDuplicate(L"bogus");
SetProperty(&rgColumnDesc[cCol].rgPropertySets, &rgColumnDesc[cCol].cPropertySets,
DBPROP_COL_NULLABLE, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL, colID);
if (DBKIND_NAME == rgColumnDesc[cCol].dbcid.eKind && rgColumnDesc[cCol].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cCol].dbcid.uName.pwszName);
rgColumnDesc[cCol].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cCol].dbcid.uName.pwszName = wcsDuplicate(L"ExtraColumn");
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cCol],
&pColumnID), S_OK);
TESTC(VerifyPropStatus(rgColumnDesc[cCol].cPropertySets,
rgColumnDesc[cCol].rgPropertySets, DBPROP_COL_NULLABLE,
DBPROPSET_COLUMN, DBPROPSTATUS_OK));
CLEANUP:
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Bad column type (wType in DBCOLUMNDESC)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_24()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].pwszTypeName);
rgColumnDesc[cColumnDesc-1].pwszTypeName = NULL;
rgColumnDesc[cColumnDesc-1].wType = 0xFFFF;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADTYPE);
CLEANUP:
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Invalid provider type name for a column => DB_E_BADTYPE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_25()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].pwszTypeName);
rgColumnDesc[cColumnDesc-1].pwszTypeName = wcsDuplicate(L"New_type_name");
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADTYPE);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc NULL ppColumnDesc => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_26()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a bad wType
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], NULL), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Autoincrementable column - DBPROP_COL_AUTOINCREMENT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_27()
{
TBEGIN
DBCOLUMNDESC *pColumnDesc = NULL;
DBORDINAL i;
CCol col;
HRESULT hres1; // for DBPROP_COL_AUTOINCREMENT set to VARIANT_TRUE
HRESULT hres2; // for DBPROP_COL_AUTOINCREMENT set to VARIANT_FALSE
HRESULT hr;
BOOL fReadOnlyAutoInc;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fSupported = TRUE;
ULONG ulStatus,
cPropSet,
cProp;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
fReadOnlyAutoInc = !SettableProperty(DBPROP_COL_AUTOINCREMENT, DBPROPSET_COLUMN);
fSupported = SupportedProperty(DBPROP_COL_AUTOINCREMENT, DBPROPSET_COLUMN);
if (!fSupported)
odtLog << "DBPROP_COL_AUTOINCREMENT is NOT SUPPORTED!\n";
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
SAFE_FREE(pColumnDesc->dbcid.uName.pwszName)
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
m_pTable->SetColumnDesc(pColumnDesc, 1);
for (i=0; i<cColumnDesc; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
if (fSupported)
{
hres1 = (col.CanAutoInc()) ? S_OK : DB_E_ERRORSOCCURRED;
hres2 = (!col.CanAutoInc() || !fReadOnlyAutoInc) ? S_OK : DB_E_ERRORSOCCURRED;
odtLog << GetColumnTypeName(&rgColumnDesc[i])
<< ((col.CanAutoInc()) ? " is AUTOINCREMENTABLE\n" : " is NOT autoincrementable\n");
}
else
{
hres1 = hres2 = DB_E_ERRORSOCCURRED;
}
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as an AUTOINCREMENT COLUMN
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_AUTOINCREMENT, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED,
DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp);
rgColumnDesc[i].bScale = 0;
CHECK(hr = AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], NULL), hres1);
odtLog << (SUCCEEDED(hr) ? "\tautoinc column added\n" : "\tautoinc column could not be added\n");
//check the state
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (S_OK == hr)
{
COMPARE(ulStatus, DBPROPSTATUS_OK);
COMPARE(fSupported, TRUE);
COMPARE(col.CanAutoInc(), TRUE);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fReadOnlyAutoInc)
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
else
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as an non autoincrement column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_AUTOINCREMENT, VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
rgColumnDesc[i].bScale = 0;
CHECK(hr = AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], NULL), hres2);
odtLog << (SUCCEEDED(hr) ? "\tNOT autoinc column added\n" : "\tNOT autoinc column could not be added\n");
// check the returned status
ulStatus = rgColumnDesc[i].rgPropertySets[0].rgProperties[0].dwStatus;
if (S_OK == hr)
{
COMPARE(ulStatus, DBPROPSTATUS_OK);
COMPARE(fSupported, TRUE);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
COMPARE(!col.CanAutoInc(), TRUE);
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fReadOnlyAutoInc)
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
else
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_COL_DEFAULT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_28()
{
TBEGIN
DBCOLUMNDESC *pColumnDesc=NULL;
DBORDINAL i;
HRESULT hr;
VARIANT value;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
ULONG ulStatus;
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName);
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
ASSERT(pColumnDesc->dbcid.uName.pwszName);
m_pTable->SetColumnDesc(pColumnDesc, 1);
if (!SupportedProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
{
odtLog << "DBPROP_COL_DEFAULT is NOT SUPPORTED.\n";
fSettable = FALSE;
fSupported = FALSE;
}
else
{
if (!SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
fSettable = FALSE;
}
for (i=0; i<cColumnDesc; i++)
{
odtLog << GetColumnTypeName(&rgColumnDesc[i]);
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a column with a default value
VariantInit(&value);
GetDefaultValue(&rgColumnDesc[i], &value, pTable);
SetDefaultProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&value);
//rgColumnDesc[i].ulColumnSize = 0;
// since the property could be supported, writeable but unavailable for
// certain data types, a return value cannot be enforced
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[0].rgProperties[0].dwStatus;
if (S_OK == hr)
{
odtLog << "\t: column has been added with a DEFAULT VALUE\n";
COMPARE(ulStatus, DBPROPSTATUS_OK);
COMPARE(fSupported, TRUE);
}
else
{
if (CHECK(hr, DB_E_ERRORSOCCURRED))
{
odtLog << "\t: column was added WITHOUT default value\n";
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
// property could be settable but failing for this data type
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
}
else
{
odtLog << "\tERROR: column was NOT added\n";
}
}
CHECK(m_pTable->DropTable(), S_OK);
// the vt type of the default property could cause problems in VariantClear
// call PrepareVariantToClear to check and fix
FreeProperties( &rgColumnDesc[i].cPropertySets, &rgColumnDesc[i].rgPropertySets);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
delete pTable;
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_COL_DESCRIPTION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_29()
{
TBEGIN
DBORDINAL i;
WCHAR *pwszName = NULL;
HRESULT hr;
BSTR pwszDescription = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hExpRes = S_OK;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
ULONG ulStatus,
cPropSet,
cProp;
if (!SupportedProperty(DBPROP_COL_DESCRIPTION, DBPROPSET_COLUMN))
{
odtLog << "DBPROP_COL_DESCRIPTION is NOT SUPPORTED.\n";
hExpRes = DB_S_ERRORSOCCURRED;
fSettable = FALSE;
fSupported = FALSE;
}
else
{
if (!SettableProperty(DBPROP_COL_DESCRIPTION, DBPROPSET_COLUMN))
{
fSettable = FALSE;
odtLog << "Implementing the desricption property as readonly is strange. Please reconsider!\n";
}
}
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
pwszName = rgColumnDesc[0].dbcid.uName.pwszName;
m_pTable->SetColumnDesc(rgColumnDesc, 1);
pwszDescription = SysAllocString(L"ColumnDescription");
for (i=0; i<cColumnDesc; i++)
{
odtLog << "column of type " << rgColumnDesc[i].pwszTypeName;
rgColumnDesc[0].dbcid.uName.pwszName = L"First_column";
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
{
if (SUCCEEDED(m_hr))
CHECK(m_pTable->DropTable(), S_OK);
continue;
}
rgColumnDesc[0].dbcid.uName.pwszName = pwszName;
// try to add the column described by rgColumnDesc[i] to the table
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_DESCRIPTION, DBTYPE_BSTR, (LPVOID)pwszDescription, DBPROPOPTIONS_OPTIONAL,
DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp);
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
if (!fSupported)
CHECK(hr, DB_S_ERRORSOCCURRED);
else if (fSettable)
CHECK(hr, S_OK);
else if (S_OK != hr)
CHECK(hr, DB_S_ERRORSOCCURRED);
if (SUCCEEDED(hr))
odtLog << ((DB_S_ERRORSOCCURRED == hr) ? ": could not add a description\n" :
": description has been added\n");
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_OK);
else
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
SysFreeString(pwszDescription);
rgColumnDesc[0].dbcid.uName.pwszName = pwszName;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_COL_FIXEDLENGTH
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_30()
{
TBEGIN
HRESULT hr;
DBCOLUMNDESC *pColumnDesc = NULL;
BOOL fFixedLength;
DBORDINAL i;
CCol col;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
ULONG ulStatus,
cPropSet,
cProp;
if (!SupportedProperty(DBPROP_COL_FIXEDLENGTH, DBPROPSET_COLUMN))
{
odtLog << "DBPROP_COL_FIXEDLENGTH is NOT SUPPORTED\n";
fSettable = FALSE;
fSupported = FALSE;
}
else
{
if (!SettableProperty(DBPROP_COL_FIXEDLENGTH, DBPROPSET_COLUMN))
fSettable = FALSE;
}
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
SetMaximumColSize(rgColumnDesc, cColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName)
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
m_pTable->SetColumnDesc(pColumnDesc, 1);
for (i=0; i<cColumnDesc; i++)
{
if ( DBTYPE_STR != rgColumnDesc[i].wType
&& DBTYPE_WSTR != rgColumnDesc[i].wType
&& DBTYPE_BYTES != rgColumnDesc[i].wType)
continue;
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// just not yet implemented
// pending for all providers to adjust the provider types schema rowset
fFixedLength = col.GetIsFixedLength();
if (fFixedLength)
odtLog << GetColumnTypeName(&rgColumnDesc[i]) <<" is fixed length\n";
else
odtLog << GetColumnTypeName(&rgColumnDesc[i]) <<" is variable length\n";
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a fixed length column
odtLog << "\ttry to add a fixed length column: ";
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_FIXEDLENGTH, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED,
DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp);
rgColumnDesc[i].bScale = 0;
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (S_OK == hr)
COMPARE(ulStatus, DBPROPSTATUS_OK);
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
else if (!fSettable)
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
}
odtLog << ((S_OK == hr)? "ok\n" : "failed\n");
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a variable_length
odtLog << "\ttry to add a variable length column: ";
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_FIXEDLENGTH, VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED,
DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp);
rgColumnDesc[i].bScale = 0;
hr = AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[i], NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (S_OK == hr)
COMPARE(ulStatus, DBPROPSTATUS_OK);
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
}
odtLog << ((S_OK == hr)? "ok\n" : "failed\n");
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_COL_NULLABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_31()
{
TBEGIN
DBCOLUMNDESC *pColumnDesc = NULL;
BOOL fNotNullable, fNullable;
DBORDINAL i;
VARIANT value, defval;
CCol col;
HRESULT hr;
DBPROP *pProp = NULL;
DBPROP *pPropDefault = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
ULONG ulStatus,
cPropSet,
cProp;
if (!SupportedProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN))
{
odtLog << "DBPROP_COL_NULLABLE is NOT SUPPORTED\n";
fSettable = FALSE;
fSupported = FALSE;
}
else
{
if (!SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN))
fSettable = FALSE;
}
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName)
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
m_pTable->SetColumnDesc(pColumnDesc, 1);
value.vt = VT_BOOL;
for (i=0; i<cColumnDesc; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
fNotNullable = FALSE;
fNullable = FALSE;
switch (col.GetNullable())
{
case 1:
odtLog << GetColumnTypeName(&rgColumnDesc[i]) <<" is nullable: \n";
fNullable = TRUE;
break;
case 0:
odtLog << GetColumnTypeName(&rgColumnDesc[i]) <<" is not nullable: \n";
fNotNullable = TRUE;
break;
default:
odtLog << GetColumnTypeName(&rgColumnDesc[i]) <<": nullable/not nullable information was not found\n";
break;
}
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a nullable one
//odtLog << "try to add a nullable column\n";
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_NULLABLE, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED, DB_NULLID,
DBPROPSET_COLUMN, &cPropSet, &cProp);
rgColumnDesc[i].bScale = 0;
// try to add a column but do not require the seccess of the operation
// though the column is declared nullable, adding a column could be unimplemented in the provider
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
if (fNullable)
CHECK(hr, S_OK);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (S_OK == hr)
COMPARE(ulStatus, DBPROPSTATUS_OK);
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a variable_length
//odtLog << "try to add a non nullable column\n";
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_NULLABLE, VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED,
DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp);
rgColumnDesc[i].bScale = 0;
// Commenting out the default value
VariantInit(&defval);
GetDefaultValue(&rgColumnDesc[i], &defval, pTable);
if (SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
SetDefaultProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
&defval, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&defval);
// it is not necessary that a not nullable column be added
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if (S_OK == hr)
COMPARE(ulStatus, DBPROPSTATUS_OK);
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (DBPROPSTATUS_OK == rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp + 1].dwStatus)
{
if (!fSupported)
COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(ulStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE);
}
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
delete pTable;
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_PRIMARYKEY
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_32()
{
TBEGIN
DBCOLUMNDESC *pColumnDesc = NULL;
DBORDINAL i;
VARIANT value;
CCol col;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
BOOL fSettable;
BOOL fDefaultIsSettable = SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN);
ULONG cPropSet1, cProp1, cPropSet2, cProp2;
DBPROPSTATUS dwStatus1, dwStatus2;
fSettable = SettableProperty(DBPROP_COL_PRIMARYKEY, DBPROPSET_COLUMN);
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
// this is to prevent SQL Server limiting the size of
// the index it creates for primary key or unique columns
SetZeroColSize(rgColumnDesc, cColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName)
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
m_pTable->SetColumnDesc(pColumnDesc, 1);
for (i=0; i<cColumnDesc; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
odtLog << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a PRIMARY KEY column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_PRIMARYKEY, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL, DB_NULLID,
DBPROPSET_COLUMN, &cPropSet1, &cProp1);
if (fDefaultIsSettable)
{
VariantInit(&value);
GetDefaultValue(&rgColumnDesc[i], &value, pTable);
SetDefaultProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
&value, DBPROPOPTIONS_OPTIONAL, DB_NULLID, DBPROPSET_COLUMN, &cPropSet2, &cProp2); // might be not supported
VariantClear(&value);
}
rgColumnDesc[i].bScale = 0;
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
dwStatus1 = rgColumnDesc[i].rgPropertySets[cPropSet1].rgProperties[cProp1].dwStatus;
dwStatus2 = rgColumnDesc[i].rgPropertySets[cPropSet2].rgProperties[cProp2].dwStatus;
if (hr != S_OK)
{
CHECK(hr, DB_S_ERRORSOCCURRED);
COMPARE(dwStatus1==DBPROPSTATUS_NOTSET || dwStatus2==DBPROPSTATUS_NOTSET, TRUE);
if (hr==DB_S_ERRORSOCCURRED && dwStatus1==S_OK)
odtLog << "\tcolumn added as a primary key\n";
if (hr==DB_S_ERRORSOCCURRED && dwStatus2==S_OK)
odtLog << "\tcolumn added with the default\n";
}
else
{
COMPARE(fSettable, TRUE);
odtLog << "\tcolumn added as a primary key\n";
COMPARE(dwStatus1, DBPROPSTATUS_OK);
COMPARE(dwStatus2, DBPROPSTATUS_OK);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a PRIMARY KEY column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_PRIMARYKEY, VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_OPTIONAL, DB_NULLID,
DBPROPSET_COLUMN, &cPropSet1, &cProp1);
rgColumnDesc[i].bScale = 0;
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
dwStatus1 = rgColumnDesc[i].rgPropertySets[cPropSet1].rgProperties[cProp1].dwStatus;
if (hr != S_OK)
{
COMPARE(fSettable, FALSE);
CHECK(hr, DB_S_ERRORSOCCURRED);
COMPARE(dwStatus1==DBPROPSTATUS_NOTSET, TRUE);
}
else
{
COMPARE(fSettable, TRUE);
odtLog << "\tcolumn was added with primary property off\n";
COMPARE(dwStatus1, DBPROPSTATUS_OK);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
SAFE_DELETE(pTable);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc DBPROP_COL_UNIQUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_33()
{
TBEGIN
DBCOLUMNDESC *pColumnDesc = NULL;
DBORDINAL i;
CCol col;
HRESULT hr;
DBPROP *pProp;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fSettable = FALSE;
BOOL fSupported = FALSE;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
// this is to prevent SQL Server limiting the size of
// the index it creates for primary key or unique columns
SetZeroColSize(rgColumnDesc, cColumnDesc);
PROVIDER_FREE(pColumnDesc->dbcid.uName.pwszName)
pColumnDesc->dbcid.uName.pwszName = wcsDuplicate(L"First_column");
m_pTable->SetColumnDesc(pColumnDesc, 1);
fSupported = SupportedProperty(DBPROP_COL_UNIQUE, DBPROPSET_COLUMN);
fSettable = SettableProperty(DBPROP_COL_UNIQUE, DBPROPSET_COLUMN);
for (i=0; i<cColumnDesc; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a UNIQUE column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_UNIQUE, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
rgColumnDesc[i].bScale = 0;
odtLog << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
odtLog << "\ttry to add a unique column; \n";
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
FindProperty(
DBPROP_COL_UNIQUE,
DBPROPSET_COLUMN,
rgColumnDesc[i].cPropertySets,
rgColumnDesc[i].rgPropertySets,
&pProp);
if (S_OK == hr)
{
COMPARE(pProp->dwStatus, DBPROPSTATUS_OK);
COMPARE(fSupported, TRUE);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(pProp->dwStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(pProp->dwStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(pProp->dwStatus, DBPROPSTATUS_NOTSETTABLE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add the column described by rgColumnDesc[i] to the table
// and set it as a unique column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
DBPROP_COL_UNIQUE, VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
rgColumnDesc[i].bScale = 0;
odtLog << "\ttry to add a not unique column; \n";
hr = AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], NULL);
FindProperty(
DBPROP_COL_UNIQUE,
DBPROPSET_COLUMN,
rgColumnDesc[i].cPropertySets,
rgColumnDesc[i].rgPropertySets,
&pProp
);
if (S_OK == hr)
{
COMPARE(pProp->dwStatus, DBPROPSTATUS_OK);
COMPARE(fSupported, TRUE);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
COMPARE(pProp->dwStatus, DBPROPSTATUS_NOTSUPPORTED);
else if (fSettable)
COMPARE(pProp->dwStatus, DBPROPSTATUS_BADVALUE);
else
COMPARE(pProp->dwStatus, DBPROPSTATUS_NOTSETTABLE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
CHECK(m_pTable->DropTable(), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Duplicate an existing column => DB_E_DUPLCATECOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_34()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column to this maximum length name table
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID),DB_E_DUPLICATECOLUMNID);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_35()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL;
DBCOLUMNDESC *oldCD = NULL;
DBORDINAL newlen = 0;
DBORDINAL oldlen = 0;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
BOOL fTxnStarted = FALSE;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
// create a table and populate it
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(StartTransaction(pITransactionLocal), S_OK);
fTxnStarted = TRUE;
// try to add a column to this maximum length name table
if (rgColumnDesc[0].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = L"transacted_column";
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[0], &pColumnID), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), S_OK);
break;
default:
TESTC(FALSE);
}
// abort retaining
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
CHECK(pITransactionLocal->Abort(NULL, TRUE, FALSE), S_OK);
// check that it is retaining (another transaction is available)
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if ( DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal)
{ // check column was added
COMPARE(CheckColInfo(oldCD, oldlen, newCD, newlen, &rgColumnDesc[0]), TRUE);
}
else
{ // check column was not added
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
newCD = NULL;
newlen = 0;
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
SAFE_RELEASE(pITransactionLocal);
if (rgColumnDesc)
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc Abort without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_36()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL;
DBCOLUMNDESC *oldCD = NULL;
DBORDINAL newlen = 0;
DBORDINAL oldlen = 0;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
// create a table and populate it
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// try to add a column to this maximum length name table
if (rgColumnDesc[0].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = L"transacted_column";
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[0], &pColumnID), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), S_OK);
break;
default:
TESTC(FALSE);
}
// abort without retaining
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// abort without retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
SUCCEEDED(m_hr)? XACT_E_NOTRANSACTION : S_OK);
}
// check column was not added
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if ( DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal)
{ // check column was added
COMPARE(CheckColInfo(oldCD, oldlen, newCD, newlen, &rgColumnDesc[0]), TRUE);
}
else
{ // check column was not added
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
newCD = NULL;
newlen = 0;
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
SAFE_RELEASE(pITransactionLocal);
if (rgColumnDesc)
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc Commit with retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_37()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
// create a table and populate it
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// try to add a column to this maximum length name table
if (rgColumnDesc[0].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"transacted_column");
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[0], &pColumnID), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), S_OK);
break;
default:
TESTC(FALSE);
}
// commit with retaining
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
CHECK(pITransactionLocal->Commit(TRUE, 0, 0), S_OK); //XACTTC_SYNC, 0), S_OK))
//check the commit with retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if (DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal)
{ // check column was not added
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
else
{ // check column was added
COMPARE(CheckColInfo(oldCD, oldlen, newCD, newlen, &rgColumnDesc[0]), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
newCD = NULL;
newlen = 0;
CLEANUP:
if (rgColumnDesc)
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
SAFE_RELEASE(pITransactionLocal);
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc Commit without retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_38()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
BOOL fDDL_LOCK = FALSE;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
// create a table and populate it
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// try to add a column to this maximum length name table
if (rgColumnDesc[0].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = L"transacted_column";
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[0], &pColumnID), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_pITableDefinition->AddColumn(
&m_pTable->GetTableID(),
&rgColumnDesc[0],
&pColumnID), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// commit without retaining
CHECK(m_hr = pITransactionLocal->Commit(FALSE, XACTTC_SYNC, 0), S_OK);
//check the commit without retaining
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE), FAILED(m_hr)? S_OK: XACT_E_NOTRANSACTION);
}
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if (DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal)
{ // check column was not added
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
else
{ // check column was added
COMPARE(CheckColInfo(oldCD, oldlen, newCD, newlen, &rgColumnDesc[0]), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
CLEANUP:
if (rgColumnDesc)
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
SAFE_RELEASE(pITransactionLocal);
ReleaseDBID(pColumnID);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc Add a column for each provider type in an empty table => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_39()
{
TBEGIN
DBORDINAL i;
WCHAR *pwszName;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
pwszName = rgColumnDesc[0].dbcid.uName.pwszName;
m_pTable->SetColumnDesc(rgColumnDesc, 1);
// for each type in DBCOLUMNDESC, add a column with maximum column size
rgColumnDesc[0].dbcid.uName.pwszName = pwszName;
for (i=0; i<cColumnDesc; i++)
{
// try to add a column from rgColumnDesc[i]
odtLog << "column name:" << rgColumnDesc[i].dbcid.uName.pwszName <<
" column type:" << rgColumnDesc[i].pwszTypeName << "\n";
rgColumnDesc[0].dbcid.uName.pwszName = L"Initial_column";
// create a table with a single column, equal to the first one in the row
if (!CHECK(m_pTable->CreateTable(0, 0), S_OK))
continue;
rgColumnDesc[0].dbcid.uName.pwszName = pwszName;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], &pColumnID), S_OK);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
rgColumnDesc[0].dbcid.uName.pwszName = pwszName;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc Add a column to a table created with a SQL command => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_40()
{
TBEGIN
DBID *pColumnID = NULL;
BOOL fTableCreation;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check wheter the commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
// set order for table creation
fTableCreation = GetModInfo()->UseITableDefinition(FALSE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column to this maximum length name table
SAFE_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = wcsDuplicate(L"new_column");
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1], &pColumnID), S_OK);
CLEANUP:
m_pTable->DropTable();
m_pTable->SetNoOfColumnDesc(cColumnDesc);
GetModInfo()->UseITableDefinition(fTableCreation);
ReleaseDBID(pColumnID);
SAFE_RELEASE(pIDBCreateCommand);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc Drop all the column of a table (via SQL stmt) and then try to add a column => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_41()
{
TBEGIN
DBID *pColumnID = NULL;
BOOL fTableCreation;
DB_LORDINAL rgCol[1] = {1};
DB_LORDINAL *prgCol = rgCol;
DBORDINAL nCol = 1;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 1;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// create a table with a single column, using a SQL command
fTableCreation = GetModInfo()->UseITableDefinition(FALSE);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// drop the only existing column from the table
TESTC_PROVIDER(S_OK == m_pTable->ExecuteCommand(
ALTER_TABLE_DROP_COLUMN,
IID_NULL,
NULL, // the table name will be the implicit one
NULL, // don't return the command statement
&nCol,
(DB_LORDINAL**)&prgCol,
EXECUTE_IFNOERROR // execute the command
));
// try to add a column to this table
SAFE_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"new_column");
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[0], &pColumnID), S_OK);
CHECK(m_pTable->DropTable(), S_OK);
CLEANUP:
GetModInfo()->UseITableDefinition(fTableCreation);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pColumnID);
SAFE_RELEASE(pIDBCreateCommand);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc Non NULL pTypeInfo in DBCOLUMNDESC => DB_E_BADTYPE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_42()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a NULL value for name pointer
rgColumnDesc[cColumnDesc-1].pTypeInfo = (ITypeInfo*)m_pITableDefinition;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), DB_E_BADTYPE);
CLEANUP:
m_pTable->DropTable();
rgColumnDesc[cColumnDesc-1].pTypeInfo = NULL;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc Missmatch between wType and pwszTypeName => DB_E_BADTYPE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_43()
{
TBEGIN
DBORDINAL i;
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
// try to add a column with a NULL value for name pointer
for (i=0; i<cColumnDesc-1 && rgColumnDesc[i].wType == rgColumnDesc[cColumnDesc-1].wType; i++);
TESTC_PROVIDER(i < cColumnDesc-2);
if (rgColumnDesc[cColumnDesc-1].pwszTypeName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].pwszTypeName);
rgColumnDesc[cColumnDesc-1].pwszTypeName = wcsDuplicate(rgColumnDesc[i].pwszTypeName);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), DB_E_BADTYPE);
CLEANUP:
m_pTable->DropTable();
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc Add a not nullable column and try to insert a null value for it
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_44()
{
TBEGIN
HRESULT hr;
DBID *pColumnID = NULL;
DBORDINAL i;
DBORDINAL nCol[1];
CCol col;
IRowsetChange *pIRowsetChange = NULL;
BOOL fFound;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT defval;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
if (!SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN) && 2 > m_cColumnDesc)
{
TESTB = TEST_SKIPPED;
goto CLEANUP1;
}
m_pTable->SetBuildColumnDesc(FALSE);
// use all the types from the not nullable one (exclusive)
m_pTable->SetColumnDesc(&rgColumnDesc[1], cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
if (rgColumnDesc[0].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.uName.pwszName = L"NewColumn";
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets, DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED, DB_NULLID, DBPROPSET_COLUMN);
if (SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
{
VariantInit(&defval);
GetDefaultValue(&rgColumnDesc[0], &defval);
SetDefaultProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
&defval, DBPROPOPTIONS_OPTIONAL); // might be not supported
VariantClear(&defval);
}
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[0], &pColumnID), S_OK);
// must update info about table in m_pTable
m_pTable->GetTableColumnInfo(&m_pTable->GetTableID());
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
for (i=0, fFound=FALSE; !fFound && i<m_pTable->CountColumnsOnTable(); i++)
{
col = m_pTable->GetColInfoForUpdate(i+1);
if (CompareDBID(rgColumnDesc[0].dbcid, *col.GetColID(), m_pIDBInitialize))
{
nCol[0] = col.GetColNum();
fFound = TRUE;
}
}
TESTC(fFound);
TEST2C_(hr = m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK, E_NOINTERFACE);
TESTC_PROVIDER(S_OK == hr);
// try to insert a null value in a not null column
hr = Insert(0, pIRowsetChange, NUMELEM(nCol), nCol);
if (DB_E_NOTSUPPORTED != hr)
CHECK(hr, DB_E_ERRORSOCCURRED);
CLEANUP:
m_pTable->SetColumnDesc(NULL);
CLEANUP1:
SAFE_RELEASE(pIRowsetChange);
CHECK(m_pTable->DropTable(), S_OK);
if (rgColumnDesc)
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc Add a column on a view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_45()
{
TBEGIN
DBID TableID;
DBID *pColumnID = NULL;
LPWSTR pwszViewName = L"VirTab";
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 1), S_OK);
m_pTable->SetViewName(pwszViewName);
if ( !CHECK(m_pTable->ExecuteCommand(
CREATE_VIEW,
IID_NULL,
pwszViewName, // the table name will be the implicit one
NULL, // don't return the command statement
0,
NULL,
EXECUTE_IFNOERROR // execute the command
), S_OK)
)
{
odtLog << "\tA view on the table could not be created\n";
goto CLEANUP;
}
// try to add a column to this maximum length name table
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = wcsDuplicate(L"new_column");
// prepare the DBID to reflect the view
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszViewName;
TEST3C_(AddColumnAndCheck(&TableID, &rgColumnDesc[cColumnDesc-1], &pColumnID),
E_FAIL, DB_E_NOTABLE, DB_SEC_E_PERMISSIONDENIED)
CLEANUP:
SAFE_RELEASE(pIDBCreateCommand);
ReleaseDBID(pColumnID);
// drop the view!
if (m_pTable->GetTableName())
m_pTable->ExecuteCommand(
DROP_VIEW,
IID_NULL,
pwszViewName, // the table name will be the implicit one
NULL, // don't return the command statement
0,
NULL,
EXECUTE_IFNOERROR // execute the command
);
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc eKind != DBKIND_NAME for a column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_46()
// try to use all the DBKIND values
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with different DBKIND values
odtLog << "Add DBKIND_GUID_NAME column\n";
if (rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName)
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName);
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_GUID_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uGuid.guid = guidModule;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = L"DBKIND_GUID_NAME";
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_GUID_PROPID column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_GUID_PROPID;
rgColumnDesc[cColumnDesc-1].dbcid.uName.ulPropid = 0;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_NAME column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = L"DBKIND_NAME";
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_PGUID_NAME column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_PGUID_NAME;
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = L"DBKIND_PGUID_NAME";
rgColumnDesc[cColumnDesc-1].dbcid.uGuid.pguid = &guidModule;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_PGUID_PROPID column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_PGUID_PROPID;
rgColumnDesc[cColumnDesc-1].dbcid.uName.ulPropid = 0;
rgColumnDesc[cColumnDesc-1].dbcid.uGuid.pguid = &guidModule;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_PROPID column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_PROPID;
rgColumnDesc[cColumnDesc-1].dbcid.uName.ulPropid = 0;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
odtLog << "Add DBKIND_GUID column\n";
rgColumnDesc[cColumnDesc-1].dbcid.eKind = DBKIND_GUID;
rgColumnDesc[cColumnDesc-1].dbcid.uName.ulPropid = 0;
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), DB_E_BADCOLUMNID);
ReleaseDBID(pColumnID);
pColumnID = NULL;
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
rgColumnDesc[cColumnDesc-1].dbcid.uName.pwszName = NULL;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
//---------------------------------------------------------------------
//
// @cmember Thread funtion for TCAddColumn
//---------------------------------------------------------------------
unsigned TCAddColumn::MyThreadProc(ULONG i)
{
DBCOLUMNDESC *pColumnDesc = NULL;
HRESULT hr;
if (i>= nThreads)
return 0;
DuplicateColumnDesc(m_rgColumnDesc, 1, &pColumnDesc);
ReleaseDBID(&pColumnDesc->dbcid, FALSE);
pColumnDesc->dbcid.eKind = DBKIND_NAME;
pColumnDesc->dbcid.uName.pwszName = m_rgName[i];
Sleep(0); // switch the context
hr = m_pITableDefinition->AddColumn(&m_pTable->GetTableID(), pColumnDesc, NULL);
Sleep(0); // switch the context
pColumnDesc->dbcid.uName.pwszName = NULL;
ReleaseColumnDesc(pColumnDesc, 1);
m_rgResult[i] = hr;
return 1;
} //TCAddColumn::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc threads with different column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_47()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i;
LPWSTR pwszBaseName = NULL;
WCHAR number[3];
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
// create n names and init the results
for (i=0; i<nThreads; i++)
m_rgName[i] = NULL;
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
pwszBaseName = m_pTable->GetTableName();
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_rgName[i] = (WCHAR*)PROVIDER_ALLOC((3+wcslen(pwszBaseName))*sizeof(WCHAR));
ASSERT(m_rgName[i]);
wcscpy(m_rgName[i], pwszBaseName);
swprintf(number, L"%02d", i);
wcscat(m_rgName[i], number);
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
TESTC_(m_rgResult[i], S_OK);
fTestResult = TEST_PASS;
CLEANUP:
DropTableAndCheck(&m_pTable->GetTableID());
for (i=0; i<nThreads; i++)
PROVIDER_FREE(m_rgName[i]);
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc threads on the same column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_48()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i, nS_OK, nDB_E_DUPLICATECOLUMNID;
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_rgName[i] = L"someOtherColumn";
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=nS_OK=nDB_E_DUPLICATECOLUMNID=0; i<nThreads; i++)
{
if (m_rgResult[i] == S_OK)
nS_OK++;
else if (CHECK(m_rgResult[i], DB_E_DUPLICATECOLUMNID))
nDB_E_DUPLICATECOLUMNID++;
else
goto CLEANUP;
}
TESTC(nS_OK== 1 && nDB_E_DUPLICATECOLUMNID == nThreads-1);
fTestResult = TEST_PASS;
CLEANUP:
DropTableAndCheck(&m_pTable->GetTableID());
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc add columns of alll known wType => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_49()
{
TBEGIN
DBORDINAL i;
DBID *pColumnID = NULL;
DBCOLUMNDESC *pColumnDesc = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
DuplicateColumnDesc(&rgColumnDesc[0], 1, &pColumnDesc);
PROVIDER_FREE(pColumnDesc[0].dbcid.uName.pwszName);
pColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"ColoanaInitiala");
m_pTable->SetColumnDesc(pColumnDesc, 1);
for (i=0; i<cColumnDesc; i++)
{
// create a table with a single column, equal to the first one in the row
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
continue;
// try to add a column from rgColumnDesc[i] with a NULL name and a valid wType
PROVIDER_FREE(rgColumnDesc[i].pwszTypeName);
odtLog << "column name: " << rgColumnDesc[i].dbcid.uName.pwszName << "\n";
CHECK(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i], &pColumnID), S_OK);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(pColumnID);
pColumnID = NULL;
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc Fully Qualified table name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_50()
{
TBEGIN
DBID TableID;
DBID BaseTableID;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
WCHAR *pwszTableName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
// create a regular table
TESTC(NULL != m_pTable);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
pwszTableName = m_pTable->GetTableName();
TableID.eKind = DBKIND_NAME;
BaseTableID.eKind = DBKIND_NAME;
BaseTableID.uName.pwszName = pwszTableName;
TESTC(GetCatalogSchemaNames(pwszTableName, &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, pwszTableName, &pwszQualTableName),S_OK);
TableID.uName.pwszName = pwszQualTableName;
m_pTable->BuildColumnDescs(&rgColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc=m_pTable->CountColumnsOnTable());
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"AltaColoana");
TESTC_(AddColumnAndCheck(&TableID, &rgColumnDesc[0], NULL, NULL, &BaseTableID), S_OK);
CLEANUP:
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
m_pTable->DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc Quoted Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_51()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TESTC(NULL != m_pTable);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
m_pTable->GetQuotedName(m_pTable->GetTableName(), &TableID.uName.pwszName);
m_pTable->BuildColumnDescs(&rgColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc=m_pTable->CountColumnsOnTable());
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"AltaColoana");
TESTC_(AddColumnAndCheck(&TableID, &rgColumnDesc[0], NULL), S_OK);
CLEANUP:
ReleaseDBID(&TableID, FALSE);
m_pTable->DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc pColumnDesc == NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_52()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
m_pTable->SetBuildColumnDesc(FALSE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), NULL, &pColumnID), E_INVALIDARG);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc cPropertySets != 0 and rgPropertySets == NULL in pColumnDesc => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_53()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
rgColumnDesc[cColumnDesc-1].cPropertySets = (BYTE)(rand()%255+1);
rgColumnDesc[cColumnDesc-1].rgPropertySets = NULL;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), E_INVALIDARG);
CLEANUP:
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
// restore the proper number of properties for the column
rgColumnDesc[cColumnDesc-1].cPropertySets = 0;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc cPropertySets == 0 and rgPropertySets != NULL in pColumnDesc => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_54()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET rgPropertySets[1];
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
rgColumnDesc[cColumnDesc-1].cPropertySets = 0;
rgColumnDesc[cColumnDesc-1].rgPropertySets = rgPropertySets;
memset(rgPropertySets, 0, sizeof(DBPROPSET));
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), S_OK);
CLEANUP:
rgColumnDesc[cColumnDesc-1].rgPropertySets = NULL;
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
// restore the property set array
rgColumnDesc[cColumnDesc-1].rgPropertySets = NULL;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc cProperties == 0 and rgProperties != NULL in pColumnDesc's propset => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_55()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET rgPropertySets[1];
DBPROP rgProperties[1];
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
rgColumnDesc[cColumnDesc-1].cPropertySets = NUMELEM(rgPropertySets);
rgColumnDesc[cColumnDesc-1].rgPropertySets = rgPropertySets;
memset(rgPropertySets, 0, sizeof(DBPROPSET));
rgPropertySets[0].guidPropertySet = DBPROPSET_COLUMN;
rgPropertySets[0].cProperties = 0;
rgPropertySets[0].rgProperties = rgProperties;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), S_OK);
CLEANUP:
rgColumnDesc[cColumnDesc-1].rgPropertySets = NULL;
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
// restore the prop array
rgPropertySets[0].rgProperties = NULL;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc cProperties != 0 and rgProperties == NULL in pColumnDesc's propset => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_56()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET rgPropertySets[1];
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
// built the property set array
rgColumnDesc[cColumnDesc-1].cPropertySets = NUMELEM(rgPropertySets);
rgColumnDesc[cColumnDesc-1].rgPropertySets = rgPropertySets;
memset(rgPropertySets, 0, sizeof(DBPROPSET));
rgPropertySets[0].guidPropertySet = DBPROPSET_COLUMN;
rgPropertySets[0].cProperties = (BYTE)(rand()%255+1);
rgPropertySets[0].rgProperties = NULL;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID), E_INVALIDARG);
CLEANUP:
rgColumnDesc[cColumnDesc-1].rgPropertySets = NULL;
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
// restore the prop counter
rgPropertySets[0].cProperties = 0;
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc pclsid not null
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_57()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hr;
POSITION pos;
CCol col;
BOOL fOleSupported = FALSE;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
// set pclsid to IID_NULL
rgColumnDesc[cColumnDesc-1].pclsid = (GUID*)&IID_NULL;
// check that pclsid is ignored
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(),
&rgColumnDesc[cColumnDesc-1], &pColumnID),S_OK);
TESTC_(m_pTable->DropTable(), S_OK);
TESTC_(m_pTable->CreateTable(10, 0), S_OK);
// check DBTYPE_IUNKNOWN is supported
for (pos = m_ColList.GetHeadPosition(); pos; )
{
col = m_ColList.GetNext(pos);
if (DBTYPE_IUNKNOWN == col.GetProviderType())
{
fOleSupported = TRUE;
break;
}
}
// check whether a DBTYPE_IUNKNOWN column can be created in the table
rgColumnDesc[cColumnDesc-1].wType = DBTYPE_IUNKNOWN;
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].pwszTypeName);
if (fOleSupported)
rgColumnDesc[cColumnDesc-1].pwszTypeName = wcsDuplicate(col.GetProviderTypeName());
hr = fOleSupported ? S_OK : DB_E_BADTYPE;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), hr);
CLEANUP:
ReleaseDBID(pColumnID);
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc NULL pwszTypeName => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddColumn::Variation_58()
{
TBEGIN
DBID *pColumnID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc-1);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
// try to add a column with a bad wType
PROVIDER_FREE(rgColumnDesc[cColumnDesc-1].pwszTypeName);
rgColumnDesc[cColumnDesc-1].pwszTypeName = NULL;
TESTC_(AddColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumnDesc-1],
&pColumnID), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
m_pTable->SetNoOfColumnDesc(cColumnDesc);
ReleaseDBID(pColumnID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddColumn::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCDropColumn)
//*-----------------------------------------------------------------------
//| Test Case: TCDropColumn - Test case for dropping columns
//| Created: 09/11/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropColumn::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
/*
//----------------------------------------------------------------------
//
// @cmember Check whether the 2 list of columns are identical,
// excepting column n
//----------------------------------------------------------------------
BOOL TCDropColumn::IsColumnDifferention(
DBCOLUMNDESC *newlist,
ULONG newlen,
DBCOLUMNDESC *oldlist,
ULONG oldlen,
ULONG n
)
{
ULONG nNewCol;
ULONG nOldCol;
if (!newlist || !oldlist)
return oldlist == newlist;
if (newlen != oldlen - 1)
return FALSE;
// it is assumed that the columns should be identical up to column n
// the new column n will be the oldcolumn n+1, the new column n+1
// should be identical to the old column n+2, etc
for (nNewCol = nOldCol = 0; nNewCol < newlen; nNewCol++)
{
if (nNewCol == n)
nOldCol++;
if (!CompareDBID(newlist[nNewCol].dbcid, oldlist[nOldCol++].dbcid, m_pIDBInitialize))
return FALSE;
}
return TRUE;
} //TCDropColumn::IsColumnDifferention
//----------------------------------------------------------------------
//
// @cmember Check whether the 2 list of columns are identical
//----------------------------------------------------------------------
BOOL TCDropColumn::ListEqual(DBCOLUMNDESC *newlist, ULONG newlen, DBCOLUMNDESC *oldlist, ULONG oldlen)
{
ULONG i;
if (!newlist || !oldlist)
return newlist == oldlist;
if (newlen != oldlen)
return FALSE;
for (i=0; i<newlen; i++)
if (!CompareDBID(newlist[i].dbcid, oldlist[i].dbcid, m_pIDBInitialize))
return FALSE;
return TRUE;
} //TCDropColumn::ListEqual
*/
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_1()
{
TBEGIN
DBID ColumnID;
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = L"Gateway2001";
TESTC_(DropColumnAndCheck(NULL, &ColumnID), E_INVALIDARG);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pColumnID in NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_2()
{
TBEGIN
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), NULL), E_INVALIDARG);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc *pTableID is DB_NULLID => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_3()
{
TBEGIN
DBID ColumnID;
DBID TableID = DB_NULLID;
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = L"Gateway2001";
TESTC_(DropColumnAndCheck(&TableID, &ColumnID), DB_E_NOTABLE);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc *pColumnID is DB_NULLID => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_4()
{
TBEGIN
DBID ColumnID;
memset(&ColumnID, 0, sizeof(DBID));
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Maximum length table name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_5()
{
TBEGIN
DBID ColumnID;
DBID TableID;
DBORDINAL n, cColumns;
DBCOLUMNINFO *rgColInfo = NULL;
LPWSTR pwszTableName;
OLECHAR *pStringBuffer = NULL;
DBORDINAL ulOrdinal = 0;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszTableName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
PRVTRACE(L"** TCDropColumn::Variation_5(): create a table with max table name: %s, %d\n",
pwszTableName, n=wcslen(pwszTableName));
TESTC_(m_hr = m_pTable->CreateTable(0, 0, pwszTableName), S_OK);
GetColumnInfo(&TableID, &cColumns, &rgColInfo, &pStringBuffer);
TESTC(0 < cColumns);
// check if the first column is bookmark or not
if (0 == rgColInfo[0].iOrdinal)
ulOrdinal = 1;
TESTC(ulOrdinal < cColumns);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = rgColInfo[ulOrdinal].pwszName;
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), S_OK);
CLEANUP:
CHECK(m_hr = m_pTable->DropTable(), S_OK);
PROVIDER_FREE(pStringBuffer);
PROVIDER_FREE(rgColInfo);
PROVIDER_FREE(pwszTableName);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc 1-char-too long table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_6()
{
BOOL fTestRes = TEST_FAIL;
DBID ColumnID;
DBID TableID;
DBCOLUMNDESC *oldCD=NULL;
DBORDINAL oldlen;
LPWSTR pwszTableName;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName+1, m_pTable->GetTableName());
pwszTableName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
TESTC_(m_hr = m_pTable->CreateTable(0, 0, pwszTableName), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = wcsDuplicate(oldCD[0].dbcid.uName.pwszName);
TESTC_(DropColumnAndCheck(&TableID, &ColumnID), DB_E_NOTABLE);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
CHECK(m_pTable->DropTable(), S_OK);
ReleaseDBID(&ColumnID, FALSE);
ReleaseDBID(&TableID, FALSE);
PROVIDER_FREE(pwszTableName);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc *pTableID contains a NULL table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_7()
{
TBEGIN
DBID ColumnID;
DBID TableID;
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = L"Gateway2001";
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TESTC_(DropColumnAndCheck(&TableID, &ColumnID), DB_E_NOTABLE);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc *pTableID contains an invalid name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_8()
{
TBEGIN
DBID ColumnID;
DBID TableID;
size_t n;
m_pTable->MakeTableName(NULL);
n = min(wcslen(m_pwszInvalidTableChars)+wcslen(m_pTable->GetTableName()), m_cMaxTableName);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildInvalidName(n, m_pTable->GetTableName(), m_pwszInvalidTableChars);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = L"foca";
TESTC_(DropColumnAndCheck(&TableID, &ColumnID), DB_E_NOTABLE);
CLEANUP:
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Maximum length for a column name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_9()
{
TBEGIN
DBID ColumnID;
LPWSTR pwszColumnName;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = pwszColumnName = BuildValidName(m_cMaxColName, L"aaabcdef");
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc 1-char-too-long column name => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_10()
{
TBEGIN
DBID ColumnID;
LPWSTR pwszColumnName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = pwszColumnName = BuildValidName(m_cMaxColName, L"aaabcdef");
ColumnID.uName.pwszName = BuildValidName(m_cMaxColName+1, m_pTable->GetTableName());
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
PROVIDER_FREE(ColumnID.uName.pwszName);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc *pColumnID contains a NULL column name pointer => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_11()
{
TBEGIN
DBID ColumnID;
// create a table, which contains a maximum size table length
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = NULL;
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc *pColumnID contains an invalid column name => E_INVALID ARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_12()
{
TBEGIN
DBID ColumnID;
LPWSTR pwszColumnName;
size_t n;
m_pTable->SetBuildColumnDesc(TRUE);
m_pTable->MakeTableName(NULL);
n = min(wcslen(m_pTable->GetTableName())+wcslen(m_pwszInvalidColChars), m_cMaxColName);
pwszColumnName = BuildInvalidName(n, m_pTable->GetTableName(), m_pwszInvalidColChars);
// create a table, which contains a maximum size table length
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = pwszColumnName;
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
PROVIDER_FREE(pwszColumnName);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Drop all the columns of a table => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_13()
{
TBEGIN
HRESULT hr;
DBID ColumnID;
DBORDINAL n, cColumns;
DBCOLUMNDESC *rgColumnDesc = NULL;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
//GetColumnInfo(&m_pTable->GetTableID(), &cColumns, &rgColInfo, &pStringBuffer);
TESTC(GetColumnDescOnTable(&m_pTable->GetTableID(), &rgColumnDesc, &cColumns));
// check for bookmarks
n = 0;
for (; n < cColumns-1; n++)
{
// drop column i
//DuplicateDBID(rgColInfo[n].columnid, &ColumnID);
DuplicateDBID(rgColumnDesc[n].dbcid, &ColumnID);
if ( !CHECK(hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID),
S_OK))
{
if (DBKIND_NAME == rgColumnDesc[n].dbcid.eKind)
odtLog << "cannot drop column " << rgColumnDesc[n].dbcid.uName.pwszName << "!\n";
}
else if (DBKIND_NAME == rgColumnDesc[n].dbcid.eKind)
odtLog << "Column "<< rgColumnDesc[n].dbcid.uName.pwszName << " was successfully dropped\n";
ReleaseDBID(&ColumnID, FALSE);
}
// try to drop the last column
DuplicateDBID(rgColumnDesc[cColumns-1].dbcid, &ColumnID);
hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (FAILED(hr))
{
if (DBKIND_NAME == rgColumnDesc[cColumns-1].dbcid.eKind)
odtLog << "cannot drop column " << rgColumnDesc[cColumns-1].dbcid.uName.pwszName << " (the last one)!\n";
}
else if (DBKIND_NAME == rgColumnDesc[cColumns-1].dbcid.eKind)
odtLog << "Column "<< rgColumnDesc[cColumns-1].dbcid.uName.pwszName << " (the last column) was successfully dropped\n";
ReleaseDBID(&ColumnID, FALSE);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
//PROVIDER_FREE(rgColInfo);
//PROVIDER_FREE(pStringBuffer);
ReleaseColumnDesc(rgColumnDesc, cColumns, TRUE);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Try to delete an inexistent column => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_14()
{
TBEGIN
DBID ColumnID;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = L"inexistentColumn";
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Table in use => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_15()
{
TBEGIN
IRowset *pIRowset=NULL;
CCol col;
m_pTable->SetRowset((IUnknown**)&pIRowset);
m_pTable->SetRIID((struct _GUID*)&IID_IRowset);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate(1);
TEST2C_(m_hr = DropColumnAndCheck(&m_pTable->GetTableID(),
col.GetColID()), S_OK, DB_E_TABLEINUSE);
odtLog << ((S_OK == m_hr)? "column was dropped\n": "column has been preserved\n");
CLEANUP:
m_pTable->SetRowset(NULL);
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Valid name of an inexistent table => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_16()
{
TBEGIN
DBID ColumnID, TableID;
m_pTable->MakeTableName(NULL);
DuplicateDBID(m_rgColumnDesc[0].dbcid, &ColumnID);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TEST2C_(m_hr = DropColumnAndCheck(&TableID, &ColumnID), DB_E_NOTABLE, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
ReleaseDBID(&ColumnID, FALSE);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Abort with retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_17()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
CCol col;
DBORDINAL nCol;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
// create a table
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
// try to drop a column from table
nCol = (ULONG)rand()%m_pTable->CountColumnsOnTable()+1;
col = m_pTable->GetColInfoForUpdate(nCol);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), S_OK);
break;
default:
TESTC(FALSE);
}
// abort retaining
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
CHECK(pITransactionLocal->Abort(NULL, TRUE, FALSE), S_OK);
//check the retaining propriety
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if ( DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal)
{ // check column was dropped
COMPARE(CheckColInfo(newCD, newlen, oldCD, oldlen, &oldCD[nCol-1]), TRUE);
}
else
{ // check column was not dropped
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
SAFE_RELEASE(pITransactionLocal);
m_hr = m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Abort without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_18()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
CCol col;
DBORDINAL nCol;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
// create a table
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
// try to drop a column from table
nCol = (DBORDINAL)rand()%m_pTable->CountColumnsOnTable()+1;
col = m_pTable->GetColInfoForUpdate(nCol);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// abort non retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
//check the non-retaining propriety
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
SUCCEEDED(m_hr)? XACT_E_NOTRANSACTION: S_OK);
}
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if ( DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal)
{ // check column was dropped
COMPARE(CheckColInfo(newCD, newlen, oldCD, oldlen, &oldCD[nCol-1]), TRUE);
}
else
{ // check column was not dropped
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
SAFE_RELEASE(pITransactionLocal);
m_hr = m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Commit with retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_19()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
CCol col;
DBORDINAL nCol;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
// create a table
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
// try to drop a column from table
nCol = (ULONG)rand()%m_pTable->CountColumnsOnTable()+1;
col = m_pTable->GetColInfoForUpdate(nCol);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), S_OK);
break;
default:
TESTC(FALSE);
}
// abort retaining
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// commit retaining
CHECK(pITransactionLocal->Commit(TRUE, 0, 0), S_OK);
// check retain property
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
// check column was dropped (oldCD must contains new CD and rgColumnDesc[0])
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if (DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal)
{ // check column was not dropped
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
else
{ // check column was dropped
COMPARE(CheckColInfo(newCD, newlen, oldCD, oldlen, &oldCD[nCol-1]), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
SAFE_RELEASE(pITransactionLocal);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Commit without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_20()
{
TBEGIN
ITransactionLocal *pITransactionLocal = NULL;
DBCOLUMNDESC *newCD = NULL, *oldCD = NULL;
DBORDINAL newlen = 0, oldlen = 0;
CCol col;
DBORDINAL nCol;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
// create a table
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
// start the transaction
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
// try to drop a column from table
nCol = (ULONG)rand()%m_pTable->CountColumnsOnTable()+1;
col = m_pTable->GetColInfoForUpdate(nCol);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
CHECK(m_pITableDefinition->DropColumn(&m_pTable->GetTableID(),
col.GetColID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// commit without retaining
CHECK(m_hr = pITransactionLocal->Commit(FALSE, 0, 0), S_OK);
// check retaining / nont retaining prop
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
FAILED(m_hr)? S_OK: XACT_E_NOTRANSACTION);
}
// check column was dropped (oldCD must contains new CD and rgColumnDesc[0])
GetColumnDescOnTable(&m_pTable->GetTableID(), &newCD, &newlen);
if (DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal)
{ // check column was not dropped
COMPARE(AreColEqual(oldCD, oldlen, newCD, newlen), TRUE);
}
else
{ // check column was dropped
COMPARE(CheckColInfo(newCD, newlen, oldCD, oldlen, &oldCD[nCol-1]), TRUE);
}
ReleaseColumnDesc(newCD, newlen);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
m_hr = m_pTable->DropTable();
SAFE_RELEASE(pITransactionLocal);
TRETURN
}
// }}
//----------------------------------------------------------------------
//
// @cmember Thread function for TCDropColumn
//----------------------------------------------------------------------
unsigned TCDropColumn::MyThreadProc(ULONG i)
{
DBID ColumnID;
HRESULT hr;
if (i>= nThreads)
return 0;
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = m_rgName[i];
Sleep(0); // switch the context
hr = m_pITableDefinition->DropColumn(&m_pTable->GetTableID(), &ColumnID);
Sleep(0); // switch the context
m_rgResult[i] = hr;
return 1;
} //TCDropColumn::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc threads on different columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_21()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i;
ULONG newnThreads;
CCol col;
// create nThreads names and init the results
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
if (m_cColumnDesc < 2)
{
odtLog << "There are too few columns in the table\n";
goto CLEANUP;
}
newnThreads = (nThreads <= (ULONG)m_cColumnDesc) ? nThreads: (ULONG)m_cColumnDesc;
for (i=0; i< newnThreads; i++)
{
m_rgResult[i] = -1;
col = m_pTable->GetColInfoForUpdate(i+1);
m_rgName[i] = wcsDuplicate(col.GetColName());
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build m_rgColumnDesc by it
for (i=0; i<newnThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(newnThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< newnThreads; i++)
{
CloseHandle(hrgThread[i]);
SAFE_FREE(m_rgName[i]);
}
for (i=0; i<newnThreads; i++)
TESTC_(m_rgResult[i], S_OK);
fTestResult = TEST_PASS;
CLEANUP:
DropTableAndCheck(&m_pTable->GetTableID());
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc threads on the same column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_22()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i, nS_OK, nDB_E_NOCOLUMN;
CCol col;
DBORDINAL nCol;
// create n names and init the results
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
if (m_cColumnDesc < 1)
{
odtLog << "There are too few columns in the table\n";
goto CLEANUP;
}
nCol = (ULONG)rand()%m_pTable->CountColumnsOnTable()+1;
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
col = m_pTable->GetColInfoForUpdate(nCol);
m_rgName[i] = wcsDuplicate(col.GetColName());
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build m_rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
{
CloseHandle(hrgThread[i]);
SAFE_FREE(m_rgName[i]);
}
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
for (i=nS_OK=nDB_E_NOCOLUMN=0; i<nThreads; i++)
{
if (m_rgResult[i] == S_OK)
nS_OK++;
else if (CHECK(m_rgResult[i], g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
nDB_E_NOCOLUMN++;
else
goto CLEANUP;
}
TESTC(nS_OK == 1 && nDB_E_NOCOLUMN == nThreads-1);
fTestResult = TEST_PASS;
CLEANUP:
DropTableAndCheck(&m_pTable->GetTableID());
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Drop a column twice => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_23()
{
TBEGIN
CCol col;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate((ULONG)rand()%m_pTable->CountColumnsOnTable()+1);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc 2 TableDefinition interfaces on the same table, try to drop 2 different columns => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_24()
{
TBEGIN
ITableDefinition *pITableDefinition = NULL;
CCol col;
TESTC(VerifyInterface(m_pIOpenRowset, IID_ITableDefinition, SESSION_INTERFACE, (IUnknown**)&pITableDefinition));
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate(1);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
col = m_pTable->GetColInfoForUpdate(2);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID(), pITableDefinition), S_OK);
CLEANUP:
SAFE_RELEASE(pITableDefinition);
m_hr = m_pTable->DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Drop as many column as possible from a table created with a SQL statement
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_25()
{
TBEGIN
DBORDINAL i, cColumns;
BOOL fOldTableCreation = GetModInfo()->UseITableDefinition(FALSE);
DBCOLUMNDESC *rgColumnDesc = NULL;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
TESTC(GetColumnDescOnTable(&m_pTable->GetTableID(), &rgColumnDesc, &cColumns));
for (i=0; i<cColumns-1; i++)
{
if ( !CHECK(m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[i].dbcid), S_OK) )
odtLog << "could not drop the column \n";
}
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[cColumns-1].dbcid);
odtLog << ((SUCCEEDED(m_hr)) ? "\tlast column was dropped\n" : "\t could not drop the last column\n");
CHECK(m_pTable->DropTable(), S_OK);
CLEANUP:
SAFE_RELEASE(pIDBCreateCommand);
GetModInfo()->UseITableDefinition(fOldTableCreation);
ReleaseColumnDesc(rgColumnDesc, cColumns, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Drop a column from a 2 column table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_26()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 2;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[0].dbcid), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc drop a column from a 1 column table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_27()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
ULONG cColumnDesc = 1;
DuplicateColumnDesc(m_rgColumnDesc, cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &rgColumnDesc[0].dbcid);
if (S_OK == m_hr)
odtLog << "the only column of the table was dropped\n";
else
odtLog << "could not drop the only column of the table\n";
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc drop a column from a non empty table => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_28()
{
TBEGIN
CCol col;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate((ULONG)rand()%m_pTable->CountColumnsOnTable()+1);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc drop a column from an empty table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_29()
{
TBEGIN
CCol col;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate((ULONG)rand()%m_pTable->CountColumnsOnTable()+1);
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), col.GetColID()), S_OK);
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc drop a nullable, an autoincrementable and a default value column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_30()
{
TBEGIN
DBORDINAL nAutoInc;
DBORDINAL nNull;
DBORDINAL nDefault;
DBORDINAL i;
BOOL fFound = FALSE;
VARIANT defVal;
DBID ColumnID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CCol col;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
TESTC_PROVIDER(SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN));
TESTC_PROVIDER(SettableProperty(DBPROP_COL_AUTOINCREMENT, DBPROPSET_COLUMN));
TESTC_PROVIDER(SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN));
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// get an autoincrementable column
nAutoInc = cColumnDesc;
for (i=0; i < cColumnDesc && !fFound; i++)
{
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
if (TRUE == (fFound = col.CanAutoInc()))
nAutoInc = i;
}
TESTC(nAutoInc < cColumnDesc);
// get the nullable and default columns
nNull = (nAutoInc+1) % cColumnDesc;
nDefault = (nAutoInc+2) % cColumnDesc;
// set autoincrementable property on a column
SetProperty(&rgColumnDesc[nAutoInc].rgPropertySets, &rgColumnDesc[nAutoInc].cPropertySets,
DBPROP_COL_AUTOINCREMENT, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
// set nullable property on a column (also add default for it)
SetProperty(&rgColumnDesc[nNull].rgPropertySets, &rgColumnDesc[nNull].cPropertySets,
DBPROP_COL_NULLABLE, VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
VariantInit(&defVal);
GetDefaultValue(&rgColumnDesc[nNull], &defVal, pTable);
SetDefaultProperty(&rgColumnDesc[nNull].rgPropertySets, &rgColumnDesc[nNull].cPropertySets,
&defVal, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&defVal);
// set default column
GetDefaultValue(&rgColumnDesc[nDefault], &defVal, pTable);
SetDefaultProperty(&rgColumnDesc[nDefault].rgPropertySets, &rgColumnDesc[nDefault].cPropertySets,
&defVal, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&defVal);
// create the table with a autoinc column, a nullable one and a default one
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
DuplicateDBID(rgColumnDesc[nAutoInc].dbcid, &ColumnID);
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (S_OK != m_hr)
odtLog << "could not drop the autoincrementable column\n";
else
odtLog << "the autoincrementable column was dropped \n";
ReleaseDBID(&ColumnID, FALSE);
DuplicateDBID(rgColumnDesc[nNull].dbcid, &ColumnID);
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (S_OK != m_hr)
odtLog << "could not drop the nullable column\n";
else
odtLog << "the nullable column was dropped \n";
ReleaseDBID(&ColumnID, FALSE);
DuplicateDBID(m_rgColumnDesc[nDefault].dbcid, &ColumnID);
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (S_OK != m_hr)
odtLog << "could not drop the default value column\n";
else
odtLog << "the default value column was dropped \n";
ReleaseDBID(&ColumnID, FALSE);
CHECK(m_pTable->DropTable(), S_OK);
CLEANUP:
delete pTable;
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc try to drop a column from a view
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_31()
{
TBEGIN
LPWSTR pwszViewName = L"HagiView"; // just a view name
DBID TableID;
CCol col;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition, m_pTable->GetTableName());
// create the view
m_pTable->SetViewName(pwszViewName);
if ( S_OK != (m_hr = m_pTable->ExecuteCommand(
CREATE_VIEW,
IID_NULL,
pwszViewName, // the table name will be the implicit one
NULL, // don't return the command statement
0,
NULL,
EXECUTE_IFNOERROR // execute the command
))
)
{
odtLog << "\t the view cannot be created\n";
goto CLEANUP;
}
TESTC_(m_hr, S_OK);
// try to drop a column from the view
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = L"HagiTable";
col = m_pTable->GetColInfoForUpdate((ULONG)rand()%m_pTable->CountColumnsOnTable()+1);
m_hr = DropColumnAndCheck(&TableID, col.GetColID());
odtLog << ((S_OK == m_hr) ? "column was dropped from view\n" : "could not drop column from view\n");
CLEANUP:
SAFE_RELEASE(pIDBCreateCommand);
// drop the view!
if (m_pTable->GetTableName())
m_hr = m_pTable->ExecuteCommand(
DROP_VIEW,
IID_NULL,
pwszViewName, // the table name will be the implicit one
NULL, // don't return the command statement
0,
NULL,
EXECUTE_IFNOERROR // execute the command
);
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc drop a column added with an alter table command => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_32()
{
TBEGIN
DBID ColumnID;
LPWSTR pwszColumnName = L"intHagi"; // the name of the integer column
LPWSTR pwszColNameAndType = NULL;
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
TESTC(NULL != m_rgColumnDesc[0].pwszTypeName); // it should be a numeric type
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
// build the column name and type argument of the command
SAFE_ALLOC(pwszColNameAndType, WCHAR, wcslen(pwszColumnName)+wcslen(m_rgColumnDesc[0].pwszTypeName)+2);
wcscpy(pwszColNameAndType, pwszColumnName);
wcscat(pwszColNameAndType, L" ");
wcscat(pwszColNameAndType, m_rgColumnDesc[0].pwszTypeName);
// create the ALTER SQL statement
if ( S_OK != (m_hr = m_pTable->ExecuteCommand(
ALTER_TABLE_ADD,
IID_NULL,
pwszColNameAndType, // the table name will be the implicit one
NULL, // don't return the command statement
0,
NULL,
EXECUTE_IFNOERROR // execute the command
))
)
{
odtLog << "Could not add a column in the table, using commands\n";
goto CLEANUP;
}
// try to drop the new column from the table
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = pwszColumnName;
TESTC_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), S_OK);
CLEANUP:
SAFE_RELEASE(pIDBCreateCommand);
SAFE_FREE(pwszColNameAndType);
CHECK(m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc try to drop columns using different DBKIND pattern
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_33()
{
TBEGIN
DBID ColumnID;
CCol col;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
// try to drop a column
col = m_pTable->GetColInfoForUpdate(2);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = wcsDuplicate(col.GetColName());
if (m_cColumnDesc > 2)
{
CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), S_OK);
}
else
{
odtLog << "too few columns, skipped the drop column given by name case \n";
}
ReleaseDBID(&ColumnID, FALSE);
col = m_pTable->GetColInfoForUpdate(4);
ColumnID.eKind = DBKIND_GUID;
memset(&ColumnID.uGuid.guid, 0, sizeof(GUID));
//NOTE: spec was changed in MDAC 2.6 to replace DB_E_BADCOLUMNID with DB_E_NOCOLUMN
// for ITableDefinition::DropColumn. So when runnning against MDAC 2.5 expect DB_E_BADCOLUMNID
// This is for SQL-specific provider. For other providers, you should modify this to test against your target spec
if (!CHECK(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
{
odtLog << "error at the guid case\n";
}
col = m_pTable->GetColInfoForUpdate(3);
ColumnID.eKind = DBKIND_GUID_NAME;
ColumnID.uGuid.guid = guidModule;
ColumnID.uName.pwszName = col.GetColName();
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
{
odtLog << "error at the guid name case\n";
}
ColumnID.eKind = DBKIND_GUID_PROPID;
memset(&ColumnID.uGuid.guid, 0, sizeof(GUID));
ColumnID.uName.ulPropid = 0L;
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN) )
{
odtLog << "error at the guid propid case\n";
}
ColumnID.eKind = DBKIND_PGUID_NAME;
ColumnID.uGuid.pguid = &guidModule;
ColumnID.uName.pwszName = NULL;
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
{
odtLog << "error at the pguid name case\n";
}
ColumnID.eKind = DBKIND_PGUID_PROPID;
ColumnID.uGuid.pguid = &guidModule;
ColumnID.uName.ulPropid = 0L;
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN) )
{
odtLog << "error at the pguid propid case\n";
}
ColumnID.eKind = DBKIND_PROPID;
ColumnID.uName.ulPropid = 0L;
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
{
odtLog << "error at the propid case\n";
}
ColumnID.eKind = 0xff;
m_hr = DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID);
if (!CHECK(m_hr, g_fSQLOLEDB25 ? DB_E_BADCOLUMNID : DB_E_NOCOLUMN))
{
odtLog << "error at the inexistent value for eKind case\n";
}
CLEANUP:
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Fully Qualified Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_34()
{
TBEGIN
DBID TableID;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
WCHAR *pwszTableName = NULL;
CCol col;
// create a regular table
TESTC(NULL != m_pTable);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
pwszTableName = m_pTable->GetTableName();
TableID.eKind = DBKIND_NAME;
TESTC(GetCatalogSchemaNames(pwszTableName, &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, pwszTableName, &pwszQualTableName),S_OK);
TableID.uName.pwszName = pwszQualTableName;
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate(1);
TESTC_(DropColumnAndCheck(&TableID, col.GetColID(), NULL, &m_pTable->GetTableID()), S_OK);
CLEANUP:
m_pTable->DropTable();
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Quoted Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropColumn::Variation_35()
{
TBEGIN
DBID TableID;
CCol col;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TESTC(NULL != m_pTable);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
m_pTable->GetQuotedName(m_pTable->GetTableName(), &TableID.uName.pwszName);
m_pTable->AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
DBKIND_NAME != m_pTable->GetTableID().eKind? m_pTable->GetTableID().uName.pwszName: NULL);
col = m_pTable->GetColInfoForUpdate(1);
TESTC_(DropColumnAndCheck(&TableID, col.GetColID()), S_OK);
CLEANUP:
m_pTable->DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropColumn::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCDropTable)
//*-----------------------------------------------------------------------
//| Test Case: TCDropTable - Test Case fo dropping a table
//| Created: 09/11/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropTable::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
// TO DO: Add your own code here
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_1()
{
if ( !CHECK(m_hr = m_pITableDefinition->DropTable(NULL), E_INVALIDARG))
return TEST_FAIL;
else
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc *pTableID is DB_NULLID => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_2()
{
DBID TableID;
TableID = DB_NULLID;
if ( !CHECK(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE))
return TEST_FAIL;
else
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Maximum length for table name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_3()
{
BOOL fTestRes = TEST_FAIL;
WCHAR* pwszTableName = NULL;
DBID TableID;
// create a maximum size table name
m_pTable->MakeTableName(NULL);
GetLiteralInfo();
pwszTableName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
odtLog << "king size table name: " << pwszTableName << ", i.e." << (wcslen(pwszTableName)) << " characters\n";
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0, pwszTableName), S_OK);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszTableName;
TESTC_(m_hr = m_pITableDefinition->DropTable(&TableID), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
m_pTable->DropTable();
PROVIDER_FREE(pwszTableName);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc 1-char-too-long table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_4()
{
BOOL fTestRes = TEST_FAIL;
WCHAR* pwszTableName = NULL, *pwszTableName1 = NULL;
DBID TableID;
// create a maximum size table name
m_pTable->MakeTableName(NULL);
GetLiteralInfo();
pwszTableName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
pwszTableName1 = BuildValidName(m_cMaxTableName+1, m_pTable->GetTableName());
odtLog << "1 char too long table name: " << pwszTableName1 << ", i.e."
<< wcslen(pwszTableName1) << " characters\n";
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0, pwszTableName), S_OK);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszTableName1;
TESTC_(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE);
fTestRes = TEST_PASS;
CLEANUP:
CHECK(m_pTable->DropTable(), S_OK);
PROVIDER_FREE(pwszTableName);
PROVIDER_FREE(pwszTableName1);
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc The pointer to the table name is NULL => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_5()
{
DBID TableID;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
if ( !CHECK(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE))
return TEST_FAIL;
else
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Table name is empty => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_6()
{
DBID TableID;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = L"";
if ( !CHECK(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE))
return TEST_FAIL;
else
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Invalid table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_7()
{
BOOL fTestRes = TEST_FAIL;
WCHAR* pwszTableName = NULL;
size_t m;
DBID TableID;
// create an invalid table name
m_pTable->MakeTableName(NULL);
GetLiteralInfo();
m = min(wcslen(m_pTable->GetTableName())+5, m_cMaxTableName);
pwszTableName = BuildInvalidName(m, m_pTable->GetTableName(), m_pwszInvalidTableChars);
odtLog << "invalid table name: " << pwszTableName << ", i.e." << wcslen(pwszTableName) << " characters\n";
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszTableName;
TESTC_(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE);
fTestRes = TEST_PASS;
CLEANUP:
PROVIDER_FREE(pwszTableName);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc A rowset is opened on table => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_8()
{
BOOL fTestRes = TEST_FAIL, fExists;
IRowset* pIRowset = NULL;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
TESTC_(m_pIOpenRowset->OpenRowset(NULL, &m_pTable->GetTableID(), NULL, IID_IRowset,
0, NULL, (IUnknown**)&pIRowset), S_OK);
fTestRes = TEST_PASS;
//try to drop the table
m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID());
if (DB_E_TABLEINUSE != m_hr && !CHECK(m_hr, S_OK))
{
odtLog << "The table was dropped, though in use \n";
fTestRes = TEST_FAIL;
}
else
{
odtLog << ((DB_E_TABLEINUSE == m_hr) ? "DB_E_TABLEINUSE returned\n": "S_OK returned\n");
//check the table still exist
if (!CHECK(m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK) ||
(fExists==(S_OK == m_hr)))
fTestRes = TEST_FAIL;
}
CLEANUP:
SAFE_RELEASE(pIRowset);
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Table in use => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_9()
{
BOOL fTestRes = TEST_FAIL, fExists;
IRowset* pIRowset = NULL;
m_pTable->SetRIID((struct _GUID*)&IID_IRowset);
m_pTable->SetRowset((IUnknown**)&pIRowset);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(10, 1), S_OK);
fTestRes = TEST_PASS;
//try to release drop the table
m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID());
if (DB_E_TABLEINUSE != m_hr && S_OK != m_hr)
{
odtLog << "The table was dropped, though in use \n";
fTestRes = TEST_FAIL;
}
else
{
odtLog << ((DB_E_TABLEINUSE == m_hr) ? "DB_E_TABLEINUSE returned\n" : "S_OK returned\n");
//check the table still exist
if (!CHECK(m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK) || (fExists==(S_OK == m_hr)))
fTestRes = TEST_FAIL;
}
CLEANUP:
m_pTable->SetRowset(NULL);
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Inexistent table => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_10()
{
WCHAR* pwszTableName = NULL;
DBID TableID;
// create a new valid table name
m_pTable->MakeTableName(NULL);
pwszTableName = m_pTable->GetTableName();
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszTableName;
if (!CHECK(m_hr = m_pITableDefinition->DropTable(&TableID), DB_E_NOTABLE))
return TEST_FAIL;
else
return TEST_PASS;
}
// }}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Abort with retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_11()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0,0), S_OK);
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned on further table access
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// abort retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, TRUE, FALSE), S_OK);
// check retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
// check table existence
CHECK(m_hr = m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DDL_IGNORE != vSupportedTxnDDL.lVal
&& DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Abort without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_12()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0,0), S_OK);
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned on further table operations
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// abort non retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
// check not retaining
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
FAILED(m_hr)? S_OK : XACT_E_NOTRANSACTION);
}
// check table existence
CHECK(m_hr = m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DDL_IGNORE != vSupportedTxnDDL.lVal
&& DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Commit with retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_13()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0,0), S_OK);
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// commit retaining
CHECK(m_hr = pITransactionLocal->Commit(TRUE, 0, 0), S_OK);
// check retaining
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
// check table existence
CHECK(m_hr = m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Commit without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_14()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0,0), S_OK);
TESTC_(m_hr = StartTransaction(pITransactionLocal), S_OK);
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
TESTC_(DropTableAndCheck(&m_pTable->GetTableID()), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
// commit not retaining
CHECK(m_hr = pITransactionLocal->Commit(FALSE, 0, 0), S_OK);
// check not retaining
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
FAILED(m_hr)? S_OK: XACT_E_NOTRANSACTION);
}
// check whether the transaction was aborted
CHECK(m_hr = m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DML == vSupportedTxnDDL.lVal);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Drop a table created with an SQL command => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_15()
{
TBEGIN
IDBCreateCommand *pIDBCreateCommand = NULL;
// check whether commands are supported
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_IDBCreateCommand,
SESSION_INTERFACE, (IUnknown**)&pIDBCreateCommand));
GetModInfo()->UseITableDefinition(FALSE);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK);
CLEANUP:
SAFE_RELEASE(pIDBCreateCommand);
GetModInfo()->UseITableDefinition(TRUE);
m_pTable->DropTable();
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Drop a table created with ITableDefinition, no rowset created => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_16()
{
BOOL fTestRes = TEST_FAIL;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Drop a table created with ITableDefinition, rowset released => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_17()
{
BOOL fTestRes = TEST_FAIL;
IRowset *pIRowset = NULL;
m_pTable->SetRowset((IUnknown**)&pIRowset);
m_pTable->SetRIID((struct _GUID*)&IID_IRowset);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
SAFE_RELEASE(pIRowset);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
m_pTable->SetRowset(NULL);
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc ITableDefinition::CreateTable, insert 10 rows, release rowset, drop the table => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_18()
{
BOOL fTestRes = TEST_FAIL;
IRowset *pIRowset = NULL;
m_pTable->SetRowset((IUnknown**)&pIRowset);
m_pTable->SetRIID((struct _GUID*)&IID_IRowset);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(10, 0), S_OK);
SAFE_RELEASE(pIRowset);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
m_pTable->SetRowset(NULL);
m_pTable->DropTable();
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc For each provider type, create a table with a single column and then drop it => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_19()
{
BOOL fTestRes = TEST_PASS;
DBORDINAL i;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->SetBuildColumnDesc(FALSE);
m_pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "\t" << rgColumnDesc[i].pwszTypeName;
m_pTable->SetColumnDesc(NULL);
m_pTable->SetColumnDesc(&rgColumnDesc[i], 1);
if (!CHECK(m_hr = m_pTable->CreateTable(0, 0), S_OK))
{
fTestRes = TEST_FAIL;
continue;
}
if (!CHECK(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK))
{
odtLog << "\n Error for type" << rgColumnDesc[i].pwszTypeName << "\n";
fTestRes = TEST_FAIL;
}
m_pTable->DropTable();
}
odtLog << "\n";
m_pTable->SetColumnDesc(NULL);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
return fTestRes;
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Drop a table twice => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_20()
{
BOOL fTestRes = TEST_FAIL;
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), S_OK);
TESTC_(m_hr = m_pITableDefinition->DropTable(&m_pTable->GetTableID()), DB_E_NOTABLE);
fTestRes = TEST_PASS;
CLEANUP:
return fTestRes;
}
// }}
//----------------------------------------------------------------------
//
// @cmember Thread procedure for TCDropTable
//----------------------------------------------------------------------
unsigned TCDropTable::MyThreadProc(ULONG i)
{
DBID TableID;
HRESULT hr;
if (i>= nThreads)
return 0;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_rgName[i];
Sleep(0); // switch the context
hr = m_pITableDefinition->DropTable(&TableID);
Sleep(0); // switch the context
m_rgResult[i] = hr;
return 1;
} //TCDropTable::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc threads on different tables
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_21()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i;
DBID TableID;
// create n names and init the results
for (i=0; i<nThreads; i++)
{
m_rgName[i] = NULL;
m_rgResult[i] = E_FAIL;
}
for (i=0; i< nThreads; i++)
{
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
m_rgName[i] = wcsDuplicate(m_pTable->GetTableName());
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
TESTC_(m_rgResult[i], S_OK);
fTestResult = TEST_PASS;
CLEANUP:
TableID.eKind = DBKIND_NAME;
for (i=0; i<nThreads; i++)
{
TableID.uName.pwszName = m_rgName[i];
// if the table was not dropped by the corresponding thread, try again
if (FAILED(m_rgResult[i]))
CHECK(DropTableAndCheck(&TableID), S_OK);
PROVIDER_FREE(m_rgName[i]);
}
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc threads on same table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_22()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i;
ULONG nS_OK = 0;
ULONG nDB_E_NOTABLE = 0;
LPWSTR pwszBaseName = NULL;
DBID TableID;
// create n names and init the results
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
pwszBaseName = m_pTable->GetTableName();
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = E_FAIL;
m_rgName[i] = pwszBaseName;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=nS_OK=nDB_E_NOTABLE=0; i<nThreads; i++)
{
if (m_rgResult[i] == S_OK)
nS_OK++;
else if (CHECK(m_rgResult[i], DB_E_NOTABLE))
nDB_E_NOTABLE++;
else
{
odtLog << "Thread " << i << ": unexpected result " << m_rgResult[i] << "\n";
goto CLEANUP;
}
}
TESTC(nS_OK == 1 && nDB_E_NOTABLE == nThreads-1);
fTestResult = TEST_PASS;
CLEANUP:
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszBaseName;
if (nS_OK < 1)
CHECK(DropTableAndCheck(&TableID), S_OK);
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Fully Qualified Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_23()
{
BOOL fTestRes = TEST_FAIL;
DBID TableID;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
WCHAR *pwszTableName = NULL;
// create a regular table
TESTC(NULL != m_pTable);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
pwszTableName = m_pTable->GetTableName();
TableID.eKind = DBKIND_NAME;
TESTC(GetCatalogSchemaNames(pwszTableName, &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, pwszTableName, &pwszQualTableName),S_OK);
TableID.uName.pwszName = pwszQualTableName;
// drop the table
TESTC_(DropTableAndCheck(&TableID), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
m_pTable->DropTable();
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Quoted Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_24()
{
BOOL fTestRes = TEST_FAIL;
DBID TableID;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TESTC(NULL != m_pTable);
m_pTable->SetBuildColumnDesc(TRUE);
TESTC_(m_pTable->CreateTable(0, 0), S_OK);
m_pTable->GetQuotedName(m_pTable->GetTableName(), &TableID.uName.pwszName);
TESTC_(DropTableAndCheck(&TableID), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
ReleaseDBID(&TableID, FALSE);
m_pTable->DropTable();
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Different DBKINDs for pTableID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropTable::Variation_25()
{
TBEGIN
DBID TableID;
m_pTable->SetBuildColumnDesc(TRUE);
// try to drop a column
TableID.eKind = DBKIND_NAME;
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TableID.uName.pwszName = m_pTable->GetTableID().uName.pwszName;
TableID.eKind = DBKIND_GUID;
TableID.uGuid.guid = guidModule;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the guid case\n";
}
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TableID.eKind = DBKIND_GUID_NAME;
TableID.uGuid.guid = guidModule;
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TableID.uName.pwszName = m_pTable->GetTableID().uName.pwszName;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the guid name case\n";
}
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TableID.eKind = DBKIND_GUID_PROPID;
TableID.uGuid.guid = guidModule;
TableID.uName.ulPropid = 0L;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the guid propid case\n";
}
TableID.eKind = DBKIND_PGUID_NAME;
TableID.uGuid.pguid = &guidModule;
TESTC_(m_hr = m_pTable->CreateTable(0, 0), S_OK);
TableID.uName.pwszName = m_pTable->GetTableID().uName.pwszName;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the pguid name case\n";
}
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TableID.eKind = DBKIND_PGUID_PROPID;
TableID.uGuid.pguid = &guidModule;
TableID.uName.ulPropid = 0L;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the pguid propid case\n";
}
TableID.eKind = DBKIND_PROPID;
TableID.uName.ulPropid = 0L;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the propid case\n";
}
TableID.eKind = 0xff;
if (!CHECK(DropTableAndCheck(&TableID), DB_E_NOTABLE))
{
odtLog << "error at the inexistent value for eKind case\n";
}
CLEANUP:
CHECK(m_hr = m_pTable->DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropTable::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(TCCreateTable)
//*-----------------------------------------------------------------------
//| Test Case: TCCreateTable - TestCase for table creation
//| Created: 09/11/97
//*-----------------------------------------------------------------------
//--------------------------------------------------------------------
//
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//--------------------------------------------------------------------------
BOOL TCCreateTable::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Session interfaces
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_1()
{
return DefaultObjectTesting(m_pITableDefinition, SESSION_INTERFACE);
}
// }}
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_2()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
CLEANUP:
// checkings, etc
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc ppTableID is a NULL pointer => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_3()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset,
0, NULL), S_OK);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc pTableID and ppTableID both NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_4()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
0, NULL, TRUE), E_INVALIDARG);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc *pTableID == DB_NULLID => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_5()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CCNDropTable((DBID*)&DB_NULLID, cColumnDesc, rgColumnDesc, IID_IRowset,
0, NULL), DB_E_BADTABLEID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc cColumnDesc == 0 => E_INVALIDARG or S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_6()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TEST2C_(CCNDropTable(NULL, 0, rgColumnDesc, IID_IRowset, 0, NULL),
S_OK, E_INVALIDARG);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc rgColumnDesc == NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_7()
{
TBEGIN
TESTC_(CCNDropTable(NULL, m_cColumnDesc, NULL, IID_IRowset,
0, NULL), E_INVALIDARG);
CLEANUP:
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc cPropertySets != 0 and rgPropertySets == NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_8()
{
TBEGIN
ULONG ulNonZero = 2;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
ulNonZero, NULL), E_INVALIDARG);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc cPropertySets is 0 and rgPropertySets != NULL => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_9()
{
TBEGIN
DBPROPSET rgPropertySets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropertySets[0], 1, rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], DBPROP_IAccessor, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
0, rgPropertySets), S_OK);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc for a property sets, cProperties != 0 and rgProperties == NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_10()
{
TBEGIN
DBPROPSET rgPropertySets[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropertySets[0], 3, NULL, DBPROPSET_ROWSET)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
1, rgPropertySets), E_INVALIDARG);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc cProperties == 0 on a property set => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_11()
{
TBEGIN
DBPROPSET rgPropertySets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// FILL_PROP_SET(rgPropertySets[0], 0, rgProp, DBPROPSET_ROWSET)
rgPropertySets[0].cProperties = 0;
rgPropertySets[0].rgProperties = rgProp;
rgPropertySets[0].guidPropertySet = DBPROPSET_ROWSET;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropertySets), S_OK);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc for a column, rgPropertySets is NULL though cPropertySets != 0 => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_12()
{
TBEGIN
ULONG cProp = 3;
DBPROPSET rgPropSets[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].rgPropertySets = rgPropSets;
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSets);
FILL_PROP_SET(rgPropSets[0], cProp, NULL, DBPROPSET_COLUMN)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), E_INVALIDARG);
CLEANUP:
// it is not required to release the memory for rgColumnDesc; it will be release in table destructor
rgColumnDesc[0].rgPropertySets = NULL;
rgColumnDesc[0].cPropertySets = 0;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc dbcid in an element of rgColumnDesc is DB_NULLID => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_13()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a dbcid of an element in rgColumnDesc to DB_NULLID
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE); // cleans the container
memcpy(&rgColumnDesc[0].dbcid, &DB_NULLID, sizeof(DBID));
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc dbcid in an element of rgColumnDesc is NULL => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_14()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a dbcid of an element in rgColumnDesc to DB_NULLID
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE); // cleans the container
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = NULL;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc not null pclsid in a DBCOLUMNDESC element
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_15()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
POSITION pos;
CCol col;
HRESULT hr;
BOOL fOleSupported = FALSE;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set pclsid to IID_NULL
rgColumnDesc[0].pclsid = (GUID*)&IID_NULL;
// check whether this is ignored for a non-DBTYPE_IUNKNOWN column
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
// check DBTYPE_IUNKNOWN is supported
for (pos = m_ColList.GetHeadPosition(); pos; )
{
col = m_ColList.GetNext(pos);
if (DBTYPE_IUNKNOWN == col.GetProviderType())
{
fOleSupported = TRUE;
break;
}
}
// check whether a DBTYPE_IUNKNOWN column can be created in the table
rgColumnDesc[0].wType = DBTYPE_IUNKNOWN;
PROVIDER_FREE(rgColumnDesc[0].pwszTypeName);
if (fOleSupported)
rgColumnDesc[0].pwszTypeName = wcsDuplicate(col.GetProviderTypeName());
hr = fOleSupported ? S_OK : DB_E_BADTYPE;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), hr);
CLEANUP:
rgColumnDesc[0].pclsid = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc empty column name => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_16()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a dbcid of an element in rgColumnDesc to DB_NULLID
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE); // cleans the container
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"");
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc empty table name => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_17()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = L"";
// create the empty name table
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTABLEID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Maximum length for table name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_18()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// create a maximum size table name
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
CLEANUP:
ReleaseDBID(&TableID, FALSE);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc 1 char too long table name => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_19()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// create a maximum size table name
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName+1, m_pTable->GetTableName());
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTABLEID);
CLEANUP:
ReleaseDBID(&TableID, FALSE);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Maximum length column name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_20()
{
TBEGIN
LPWSTR pwszColumnName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a dbcid of an element in rgColumnDesc to DB_NULLID
pwszColumnName = rgColumnDesc[0].dbcid.uName.pwszName;
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszColumnName);
// save the number of propertySets, to be able to release it ok
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
CLEANUP:
PROVIDER_FREE(pwszColumnName);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc 1 char too long column name => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_21()
{
TBEGIN
WCHAR *pwszColumnName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
if (DBKIND_NAME == rgColumnDesc[0].dbcid.eKind)
pwszColumnName = rgColumnDesc[0].dbcid.uName.pwszName;
else
pwszColumnName = wcsDuplicate(L"ColumnName");
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName+1, pwszColumnName);
// save the number of propertySets, to be able to release it ok
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
PROVIDER_FREE(pwszColumnName);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc ulColumnSize 0 for a variable-length column => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_22()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// go through the list of column and set the column size to 0 for all variable-length columns
for (ULONG i=0; i<cColumnDesc; i++)
{
if (!IsFixedLength(rgColumnDesc[i].wType))
{
rgColumnDesc[i].ulColumnSize = 0;
odtLog << "Column " << rgColumnDesc[i].dbcid.uName.pwszName << " is set to length 0!\n";
}
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc For each provider type create and drop a table with a single column => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_23()
{
TBEGIN
DBCOLUMNDESC *tempColumnDesc;
DBORDINAL i;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// go through the list of column and set the column size to 0 for all variable-length columns
for (i=0, tempColumnDesc=rgColumnDesc; i<cColumnDesc; i++, tempColumnDesc++)
{
odtLog << "Create a table with a single column " << tempColumnDesc->dbcid.uName.pwszName << "\n";
CHECK(CCNDropTable(NULL, 1, tempColumnDesc, IID_IRowset, 0, NULL), S_OK);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc invalid table name => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_24()
{
TBEGIN
WCHAR *pwszTableName = NULL;
size_t n, m;
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
m = min(n=wcslen(m_pTable->GetTableName())+5, m_cMaxTableName);
pwszTableName = BuildInvalidName(m, m_pTable->GetTableName(), m_pwszInvalidTableChars);
TableID.uName.pwszName = pwszTableName;
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTABLEID);
CLEANUP:
PROVIDER_FREE(pwszTableName);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc pTableID provides the name of an existing table => DB_E_DUPLICATETABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_25()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, &TableID,
cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, NULL, NULL), S_OK);
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_DUPLICATETABLEID);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc valid riid and NULL ppRowset => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_26()
{
TBEGIN
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL,
cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, &pTableID, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc invalid column name => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_27()
{
TBEGIN
WCHAR *pwszColName = NULL;
size_t n, m;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// create an invalid column name
m = min(n=wcslen(rgColumnDesc[0].dbcid.uName.pwszName)+5, m_cMaxColName);
if (DBKIND_NAME == rgColumnDesc[0].dbcid.eKind)
pwszColName = rgColumnDesc[0].dbcid.uName.pwszName;
else
pwszColName = wcsDuplicate(L"ColumnName");
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = BuildInvalidName(m,
pwszColName, m_pwszInvalidColChars);
SAFE_FREE(pwszColName);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc invalid type name for a column (NULL, empty or inexistent
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_28()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// build the column type name
SAFE_FREE(rgColumnDesc[0].pwszTypeName);
odtLog << "NULL type name\n";
rgColumnDesc[0].pwszTypeName = NULL;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
// verify empty string (bug 26380, empty string for type name should be equivalent to specifying a NULL pointer)
odtLog << "empty type name for a column\n";
rgColumnDesc[0].pwszTypeName = wcsDuplicate(L"");
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
rgColumnDesc[0].pwszTypeName = wcsDuplicate(L"Pay a trip to Europe");
odtLog << "invalid type name (" << rgColumnDesc[0].pwszTypeName <<")\n";
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTYPE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc invalid wType for a column => DB_E_BADTYPE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_29()
{
TBEGIN
DBTYPE wInvalidType = 0xffff;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
PROVIDER_FREE(rgColumnDesc[0].pwszTypeName);
rgColumnDesc[0].pwszTypeName = NULL;
rgColumnDesc[0].wType = wInvalidType;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTYPE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc wType and pswzTypeName mismatch in a column description => DB_E_BADTYPE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_30()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set an invalid wType
TESTC_PROVIDER(cColumnDesc >= 7);
// each column was assigned a different type; try to mismatch a pwszTypeName and wType for the first col
PROVIDER_FREE(rgColumnDesc[0].pwszTypeName);
rgColumnDesc[0].pwszTypeName = rgColumnDesc[7].pwszTypeName;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADTYPE);
CLEANUP:
if (cColumnDesc > 1)
rgColumnDesc[0].pwszTypeName = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc not null pTypeInfo => DB_E_BADTYPE (for the time being
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_31()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a not NULL pTypeInfo
rgColumnDesc[0].pTypeInfo = (ITypeInfo*)pITableDefinition();
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), E_NOINTERFACE, DB_E_BADTYPE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc duplicate column identifiers => DB_E_DUPLICATECOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_32()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set an invalid wType
TESTC_PROVIDER(2 < cColumnDesc);
// each column was assigned a different type; try to mismatch a pwszTypeName and wType for the first col
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
DuplicateDBID(rgColumnDesc[1].dbcid, &rgColumnDesc[0].dbcid);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_DUPLICATECOLUMNID);
CLEANUP:
memset(&rgColumnDesc[0].dbcid, 0, sizeof(DBID));
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc improper eKind value in a DBID => DB_E_BADCOLUMNID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_33()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set improper eKind in a column DBID
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = INVALID_DBKIND;
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_BADCOLUMNID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc invalid property value on column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_34()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
LONG lValue = 12;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set improper value (different type than required) for a property value of a column
// DBPROPOPTIONS_REQUIRED
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_COLUMN)
FILL_PROP(rgProp[0], DBPROP_COL_UNIQUE, DBTYPE_I4, V_I4, lValue, DBPROPOPTIONS_REQUIRED)
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_ERRORSOCCURRED);
// set improper value (different type) for a column DBPROPOPTIONS_OPTIONAL
// try to set the property value of the rowset trough a column
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_COLUMN)
FILL_PROP(rgProp[0], DBPROP_COL_UNIQUE, DBTYPE_I4, V_I4, lValue, DBPROPOPTIONS_OPTIONAL)
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_S_ERRORSOCCURRED);
// try to set a rowset property through a column, DBPROPOPTIONS_REQUIRED
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], DBPROP_BOOKMARKS, DBTYPE_I4, V_I4, lValue, DBPROPOPTIONS_REQUIRED)
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_ERRORSOCCURRED);
// try to set a rowset property through a column, DBPROPOPTIONS_OPTIONAL
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], DBPROP_BOOKMARKS, DBTYPE_I4, V_I4, lValue, DBPROPOPTIONS_OPTIONAL)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_S_ERRORSOCCURRED);
CLEANUP:
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Invalid column precision => DB_E_BADPRECISION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_35()
{
TBEGIN
const int n=8;
BYTE testValues[n];
HRESULT testResult[n]={S_OK, S_OK, S_OK, S_OK, S_OK, S_OK, DB_E_BADPRECISION, DB_E_BADPRECISION};
CCol Col;
ULONG cPrecision;
DBORDINAL i;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
testValues[0] = 0;
testValues[1] = 1;
for (i=0; i<cColumnDesc; i++)
{
Col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
ASSERT(0 == wcscmp(Col.GetProviderTypeName(), GetColumnTypeName(&rgColumnDesc[i])));
if (rgColumnDesc[i].wType == DBTYPE_NUMERIC)
testResult[0] = DB_E_BADPRECISION;
else
testResult[0] = S_OK;
testResult[6] = S_OK;
testResult[7] = S_OK;
if (rgColumnDesc[i].wType == DBTYPE_NUMERIC)
{
testResult[6] = DB_E_BADPRECISION;
testResult[7] = DB_E_BADPRECISION;
}
testValues[2] = (BYTE)(Col.GetPrecision()/3);
testValues[3] = (BYTE)(2*Col.GetPrecision()/3);
testValues[4] = (BYTE)Col.GetPrecision()-1;
testValues[5] = (BYTE)Col.GetPrecision();
testValues[6] = (BYTE)Col.GetPrecision()+1;
testValues[7] = (BYTE)Col.GetPrecision()+10;
odtLog << rgColumnDesc[i].pwszTypeName <<" ("
<< rgColumnDesc[i].dbcid.uName.pwszName << ") max precision =" << testValues[5] << "\n";
odtLog << "\t" << "precisions tested :";
for (cPrecision=0; cPrecision<n; cPrecision++)
odtLog << "\t" << (ULONG)testValues[cPrecision];
odtLog << "\n";
for (cPrecision=0; cPrecision<n; cPrecision++)
{
rgColumnDesc[i].bPrecision = (BYTE)testValues[cPrecision];
rgColumnDesc[i].ulColumnSize = 0;
rgColumnDesc[i].bScale = 0;
if (!CHECK(CCNDropTable(NULL, 1, &rgColumnDesc[i], IID_IRowset, 0, NULL), testResult[cPrecision]))
{
odtLog << "Error for precision " << testValues[cPrecision] << "\n";
}
}
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc invalid scale on column => DB_E_BADSCALE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_36()
{
TBEGIN
const int n=7;
BYTE testValues[n];
HRESULT testResult[n]={S_OK, S_OK, S_OK, S_OK, S_OK, DB_E_BADSCALE, DB_E_BADSCALE};
CCol Col;
ULONG cScale, m;
DBORDINAL i;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
testValues[0] = 0;
testValues[1] = 1;
for (i=0; i<cColumnDesc; i++)
{
Col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
ASSERT(0 == wcscmp(Col.GetProviderTypeName(), GetColumnTypeName(&rgColumnDesc[i])));
odtLog << rgColumnDesc[i].pwszTypeName << "\n";
testResult[0] = S_OK;
testResult[1] = S_OK;
testValues[0] = 0;
testValues[1] = 1;
testValues[2] = 100;
testValues[3] = (BYTE)Col.GetPrecision()+1;
m = 4;
if ((rgColumnDesc[i].wType == DBTYPE_NUMERIC) || (rgColumnDesc[i].wType == DBTYPE_DECIMAL))
{
m = 7;
if (Col.GetMinScale()>0)
{
testResult[0] = DB_E_BADSCALE;
testResult[1] = DB_E_BADSCALE;
}
testResult[4] = S_OK;
testValues[1] = (BYTE)max(Col.GetMinScale()-1, 0);
testValues[2] = (BYTE)Col.GetMinScale();
testValues[3] = (BYTE)((Col.GetMinScale()+Col.GetMaxScale())/2);
testValues[4] = (BYTE)Col.GetMaxScale();
testValues[5] = (BYTE)Col.GetMaxScale()+1;
testValues[6] = (BYTE)Col.GetMaxScale();
// tests
for (cScale=0; cScale<m; cScale++)
{
rgColumnDesc[i].bScale = (BYTE)testValues[cScale];
if (cScale+1 == m)
{
rgColumnDesc[i].bPrecision = max(1, Col.GetMaxScale()-2);
odtLog << "\nprecision: " << rgColumnDesc[i].bPrecision
<< ", scale: " << testValues[cScale] <<"\n";
}
else
odtLog << "\t" << testValues[cScale];
if (!CHECK(CCNDropTable(NULL, 1, &rgColumnDesc[i], IID_IRowset, 0, NULL), testResult[cScale]))
{
odtLog << "Error for scale " << testValues[cScale] << "\n";
}
}
odtLog << "\n";
}
else
{
testResult[4] = S_OK;
for (cScale=0; cScale<m; cScale++)
{
rgColumnDesc[i].bScale = (BYTE)testValues[cScale];
if (cScale+1 == m)
rgColumnDesc[cScale].bPrecision = Col.GetMaxScale()-1;
if (!CHECK(CCNDropTable(NULL, 1, &rgColumnDesc[i],
IID_IRowset, 0, NULL), testResult[cScale]))
{
odtLog << "Error for scale " << testValues[cScale] << "\n";
}
}
}
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_SETIFCHEAP => DB_S_ERRORSOCCURRED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_37()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a column property that doesn't belong to the column, rowset or table propriety group
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_DBINIT)
FILL_PROP(rgProp[0], DBPROP_AUTH_PASSWORD, DBTYPE_BSTR, V_BSTR,
SysAllocString(L"passwd"), DBPROPOPTIONS_OPTIONAL)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_S_ERRORSOCCURRED);
CLEANUP:
SysFreeString(V_BSTR(&rgProp[0].vValue));
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(38)
//*-----------------------------------------------------------------------
// @mfunc col prop is not in the Column, Rowset or Table property group and dwOption is DBPROP_REQUIRED => DB_E_ERRORSOCCURRED
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_38()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set a column property ID that is not valid
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], NUMELEM(rgProp), rgProp, DBPROPSET_DBINIT)
FILL_PROP(rgProp[0], DBPROP_AUTH_PASSWORD, DBTYPE_BSTR, V_BSTR,
SysAllocString(L"passwd"), DBPROPOPTIONS_REQUIRED)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
SysFreeString(V_BSTR(&rgProp[0].vValue));
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(39)
//*-----------------------------------------------------------------------
// @mfunc invalid propID for a column propriety
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_39()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// set an inexistent column property with DBPROPOPTIONS_OPTIONAL
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_COLUMN)
FILL_PROP(rgProp[0], 0xffff, DBTYPE_I4, V_I4, 42, DBPROPOPTIONS_OPTIONAL)
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_S_ERRORSOCCURRED);
// set an inexistent column property with DBPROPOPTIONS_REQUIRED
rgColumnDesc[0].cPropertySets = NUMELEM(rgPropSet);
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_COLUMN)
FILL_PROP(rgProp[0], 0xffff, DBTYPE_I4, V_I4, 42, DBPROPOPTIONS_REQUIRED)
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(40)
//*-----------------------------------------------------------------------
// @mfunc colid in DBPROP of a column property is ignored
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_40()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPID rgPropID[] = { DBPROP_COL_AUTOINCREMENT, DBPROP_COL_NULLABLE};
ULONG i;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
// set a column property that is not ...
for (i=0; i<NUMELEM(rgPropID); i++)
{
if (SettableProperty(rgPropID[i], DBPROPSET_COLUMN))
break;
}
TESTC_PROVIDER(i<NUMELEM(rgPropID));
rgColumnDesc[0].cPropertySets = 1;
rgColumnDesc[0].rgPropertySets = rgPropSet;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_COLUMN)
FILL_PROP(rgProp[0], rgPropID[i], DBTYPE_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
// set colID to a value different from DB_NULLID
rgProp[0].colid.eKind = DBKIND_NAME;
rgProp[0].colid.uName.pwszName = wcsDuplicate(L"someColumn");
// check colid is ignored for the column property
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
COMPARE(DBPROPSTATUS_OK == rgProp[0].dwStatus, TRUE);
// check colid is ignored for the column property
rgProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
COMPARE(DBPROPSTATUS_OK == rgProp[0].dwStatus, TRUE);
CLEANUP:
PROVIDER_FREE(rgProp[0].colid.uName.pwszName);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }}
// {{ TCW_VAR_PROTOTYPE(41)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_41()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
DBID *pTableID = NULL;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
IRowsetInfo *pIRowsetInfo = NULL;
BOOL fAbortPreserve = TRUE;
ULONG cReadPropSet = 0;
DBPROPSET *rgReadPropSet = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
HRESULT hr;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// if possible, prepare to ask DBPROP_ABORTPRESERVE to be set to VARIANT_FALSE
if (SettableProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET))
{
::SetProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET, &cPropSet, &rgPropSet,
(LPVOID)VARIANT_FALSE, VT_BOOL, DBPROPOPTIONS_REQUIRED, DB_NULLID);
}
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL,
cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
if (pIRowsetInfo)
fAbortPreserve = GetProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET, pIRowsetInfo, VARIANT_TRUE);
// abort retaining
CHECK(pITransactionLocal->Abort(NULL, TRUE, FALSE), S_OK);
// check that it is retaining (another transaction is available)
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
// abort retaining and check that the table doesn't exist anymore
CHECK(m_hr = m_pTable->DoesTableExist(pTableID, &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal);
if (fExists)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
}
// test zombie rowset
if (pIRowsetInfo)
TESTC_(pIRowsetInfo->GetProperties(0, NULL, &cReadPropSet, &rgReadPropSet), fAbortPreserve? S_OK: E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
SAFE_RELEASE(pIRowsetInfo);
ReleaseDBID(pTableID);
FreeProperties( &cPropSet, &rgPropSet);
FreeProperties( &cReadPropSet, &rgReadPropSet);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(42)
//*-----------------------------------------------------------------------
// @mfunc Abort without retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_42()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
DBID *pTableID = NULL;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
IRowsetInfo *pIRowsetInfo = NULL;
BOOL fAbortPreserve = TRUE;
ULONG cReadPropSet = 0;
DBPROPSET *rgReadPropSet = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// if possible, prepare to ask DBPROP_ABORTPRESERVE to be set to VARIANT_FALSE
if (SettableProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET))
{
::SetProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET, &cPropSet, &rgPropSet,
(LPVOID)VARIANT_FALSE, VT_BOOL, DBPROPOPTIONS_REQUIRED, DB_NULLID);
}
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(CreateAndCheckTable(m_pITableDefinition, NULL, NULL,
cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
fAbortPreserve = GetProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET, pIRowsetInfo, VARIANT_TRUE);
// abort non retaining
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
// check that it is retaining (another transaction is available)
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
FAILED(m_hr)? S_OK : XACT_E_NOTRANSACTION);
}
// abort retaining and check that the table doesn't exist anymore
CHECK(m_hr = m_pTable->DoesTableExist(pTableID, &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DDL_IGNORE == vSupportedTxnDDL.lVal
|| DBPROPVAL_TC_DDL_COMMIT == vSupportedTxnDDL.lVal);
if (fExists)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
}
// test zombie rowset
TESTC_(pIRowsetInfo->GetProperties(0, NULL, &cReadPropSet, &rgReadPropSet), fAbortPreserve? S_OK: E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
SAFE_RELEASE(pIRowsetInfo);
ReleaseDBID(pTableID);
FreeProperties( &cPropSet, &rgPropSet);
FreeProperties(&cReadPropSet, &rgReadPropSet);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(43)
//*-----------------------------------------------------------------------
// @mfunc Commit retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_43()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
DBID *pTableID = NULL;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
IRowsetInfo *pIRowsetInfo = NULL;
BOOL fCommitPreserve = TRUE;
ULONG cReadPropSet = 0;
DBPROPSET *rgReadPropSet = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// if possible, prepare to ask DBPROP_ABORTPRESERVE to be set to VARIANT_FALSE
if (SettableProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET))
{
::SetProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET, &cPropSet, &rgPropSet,
(LPVOID)VARIANT_FALSE, VT_BOOL, DBPROPOPTIONS_REQUIRED, DB_NULLID);
}
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(CreateAndCheckTable(m_pITableDefinition, NULL, NULL,
cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
fCommitPreserve = GetProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET, pIRowsetInfo, VARIANT_TRUE);
// commit retaining
CHECK(m_hr = pITransactionLocal->Commit(TRUE, 0, 0), S_OK);
// check that it is retaining (another transaction is available)
CHECK(m_hr = pITransactionLocal->Abort(NULL, FALSE, FALSE), S_OK);
}
// abort retaining and check that the table doesn't exist anymore
CHECK(m_hr = m_pTable->DoesTableExist(pTableID, &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DML != vSupportedTxnDDL.lVal);
if (fExists)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
}
// test zombie rowset
TESTC_(pIRowsetInfo->GetProperties(0, NULL, &cReadPropSet, &rgReadPropSet), fCommitPreserve? S_OK: E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
SAFE_RELEASE(pIRowsetInfo);
DropTableAndCheck(pTableID);
ReleaseDBID(pTableID);
FreeProperties( &cPropSet, &rgPropSet);
FreeProperties(&cReadPropSet, &rgReadPropSet);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(44)
//*-----------------------------------------------------------------------
// @mfunc Commit non-retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_44()
{
TBEGIN
BOOL fExists;
ITransactionLocal *pITransactionLocal = NULL;
DBID *pTableID = NULL;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
IRowsetInfo *pIRowsetInfo = NULL;
BOOL fCommitPreserve = TRUE;
ULONG cReadPropSet = 0;
DBPROPSET *rgReadPropSet = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
VARIANT vSupportedTxnDDL;
TESTC_PROVIDER(VerifyInterface(m_pITableDefinition, IID_ITransactionLocal,
SESSION_INTERFACE, (IUnknown**)&pITransactionLocal));
VariantInit(&vSupportedTxnDDL);
TESTC_PROVIDER(GetProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO,
g_pIDBInitialize, &vSupportedTxnDDL));
TESTC(VT_I4 == vSupportedTxnDDL.vt);
// what values should we accept?
TESTC_PROVIDER(DBPROPVAL_TC_NONE != vSupportedTxnDDL.lVal);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(StartTransaction(pITransactionLocal), S_OK);
// if possible, prepare to ask DBPROP_ABORTPRESERVE to be set to VARIANT_FALSE
if (SettableProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET))
{
::SetProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET, &cPropSet, &rgPropSet,
(LPVOID)VARIANT_FALSE, VT_BOOL, DBPROPOPTIONS_REQUIRED, DB_NULLID);
}
switch(vSupportedTxnDDL.lVal)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(CreateAndCheckTable(m_pITableDefinition, NULL, NULL,
cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
// error should be returned
CHECK(m_hr = m_pITableDefinition->CreateTable(NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, cPropSet, rgPropSet, &pTableID,
(IUnknown**)&pIRowsetInfo), S_OK);
break;
default:
TESTC(FALSE);
}
if (DBPROPVAL_TC_DDL_COMMIT != vSupportedTxnDDL.lVal)
{
fCommitPreserve = GetProperty(DBPROP_COMMITPRESERVE, DBPROPSET_ROWSET, pIRowsetInfo, VARIANT_TRUE);
// commit non retaining
CHECK(m_hr = pITransactionLocal->Commit(FALSE, 0, 0), S_OK);
// check that it is retaining (another transaction is available)
CHECK(pITransactionLocal->Abort(NULL, FALSE, FALSE),
FAILED(m_hr)? S_OK: XACT_E_NOTRANSACTION);
}
// abort retaining and check that the table doesn't exist anymore
CHECK(m_hr = m_pTable->DoesTableExist(pTableID, &fExists), S_OK);
COMPARE(fExists, DBPROPVAL_TC_DML != vSupportedTxnDDL.lVal);
if (fExists)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
goto CLEANUP;
}
// test zombie rowset
TESTC_(pIRowsetInfo->GetProperties(0, NULL, &cReadPropSet, &rgReadPropSet), fCommitPreserve? S_OK: E_UNEXPECTED);
CLEANUP:
SAFE_RELEASE(pITransactionLocal);
SAFE_RELEASE(pIRowsetInfo);
DropTableAndCheck(pTableID);
ReleaseDBID(pTableID);
FreeProperties( &cPropSet, &rgPropSet);
FreeProperties(&cReadPropSet, &rgReadPropSet);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(45)
//*-----------------------------------------------------------------------
// @mfunc Autoincrementable columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_45()
{
TBEGIN
DBORDINAL i;
HRESULT resA, resB;
CCol col;
BOOL fReadWriteAutoInc;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
ULONG cPropSet, cProp;
fReadWriteAutoInc = (GetPropInfoFlags(DBPROP_COL_AUTOINCREMENT, DBPROPSET_COLUMN,
m_pThisTestModule->m_pIUnknown, DATASOURCE_INTERFACE) & DBPROPFLAGS_WRITE);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
// try all data types
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
// try to create a table in which column rgColumnDesc[i].pwszTypeName is:
// a) autoincrementable
// b) not autoincrementable
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
resA = col.CanAutoInc()? S_OK: DB_E_ERRORSOCCURRED;
resB = !col.CanAutoInc() || fReadWriteAutoInc? S_OK : DB_E_ERRORSOCCURRED;
// create a table with an autoincrementable column
rgColumnDesc[i].bScale = 0;
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_AUTOINCREMENT,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED, DB_NULLID,
DBPROPSET_COLUMN, &cPropSet, &cProp);
CHECK(hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
0, NULL), resA);
if (S_OK == hr)
{
COMPARE(rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus, DBPROPSTATUS_OK);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fReadWriteAutoInc && !col.CanAutoInc())
COMPARE(rgColumnDesc[i].rgPropertySets[0].rgProperties[0].dwStatus, DBPROPSTATUS_NOTSETTABLE);
}
odtLog << ((hr == S_OK) ? "\tcolumn added for DBPROPCOL_AUTOINCREMENT set to VARIANT_TRUE\n":
"\tcolumn NOT added for DBPROPCOL_AUTOINCREMENT set to VARIANT_TRUE\n");
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
// create a table with a column property value to VARIANT_FALSE for DBPROP_COL_AUTOINCREMENT
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_AUTOINCREMENT,
VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED, DB_NULLID,
DBPROPSET_COLUMN, &cPropSet, &cProp);
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), resB);
odtLog << ((S_OK == hr) ? "\tcolumn added for DBPROPCOL_AUTOINCREMENT set to VARIANT_FALSE\n":
"\tcolumn NOT added for DBPROPCOL_AUTOINCREMENT set to VARIANT_FALSE\n");
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(46)
//*-----------------------------------------------------------------------
// @mfunc Default values
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_46()
{
TBEGIN
DBORDINAL i;
CCol col;
VARIANT value;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
HRESULT hr;
ULONG cPropSet, cProp;
if (!SupportedProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
{
fSettable = FALSE;
fSupported = FALSE;
}
else
if (!SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
fSettable = FALSE;
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
// try to create a table in which column rgColumnDesc[i].pwszTypeName has a default value
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// create a table with a default value column
VariantInit(&value);
GetDefaultValue(&rgColumnDesc[i], &value, pTable);
SetDefaultProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED, DB_NULLID, DBPROPSET_COLUMN, &cPropSet, &cProp); // might be not supported
VariantClear(&value);
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK == hr)
{
COMPARE(rgColumnDesc[i].rgPropertySets[0].rgProperties[0].dwStatus, DBPROPSTATUS_OK);
}
else
{
odtLog << "Failed on creating a table with a DBPROP_COL_DEFAULT property value set for this type.\n";
CHECK(hr, DB_E_ERRORSOCCURRED);
if (!fSupported)
{
COMPARE(rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus, DBPROPSTATUS_NOTSUPPORTED);
}
else
if (!fSettable)
{
COMPARE(rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus, DBPROPSTATUS_BADVALUE);
}
else
COMPARE(rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus, DBPROPSTATUS_BADVALUE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
delete pTable;
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(47)
//*-----------------------------------------------------------------------
// @mfunc Column descriptions
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_47()
{
TBEGIN
DBORDINAL i;
CCol col;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
// try to create a table in which column rgColumnDesc[i].pwszTypeName has a description
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// create a table with a described column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_DESCRIPTION,
VT_BSTR, (LPVOID)L"description");
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK != hr && !CHECK(hr, DB_S_ERRORSOCCURRED))
{
odtLog << "Could not create a table with DBPROP_COL_DESCRIPTION property value set for this type.\n";
}
else
{
if (DB_S_ERRORSOCCURRED == hr)
odtLog << "DB_S_ERRORSOCCURRED\n";
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(48)
//*-----------------------------------------------------------------------
// @mfunc Variable length columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_48()
{
TBEGIN
DBORDINAL i;
VARIANT value;
CCol col;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
value.vt = VT_BOOL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
if ( DBTYPE_STR != rgColumnDesc[i].wType
&& DBTYPE_WSTR != rgColumnDesc[i].wType
&& DBTYPE_BYTES != rgColumnDesc[i].wType)
continue;
odtLog << "Type " << rgColumnDesc[i].pwszTypeName << "\n";
// try to create a table in which column rgColumnDesc[i].pwszTypeName is:
// a) fixed length
// b) variable length
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// create a table with an fixed length column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_FIXEDLENGTH,
VT_BOOL, (LPVOID)VARIANT_TRUE);
odtLog << "\ttry to create a table with a fixed length column of type "
<< rgColumnDesc[i].pwszTypeName << "\n";
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK != hr && !CHECK(hr, DB_S_ERRORSOCCURRED))
{
odtLog << "\t\tProblems in creating a table with DBPROP_COL_FIXEDLENGTH property value set to VARIANT_TRUE for this column.\n";
}
FreeProperties( &rgColumnDesc[i].cPropertySets, &rgColumnDesc[i].rgPropertySets);
// create a table with a column property value set to VARIANT_FALSE for DBPROP_COL_FIXEDLENGTH
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_FIXEDLENGTH,
VT_BOOL, (LPVOID)VARIANT_FALSE);
odtLog << "\ttry to create a table with a variable length column of type "
<< rgColumnDesc[i].pwszTypeName << "\n";
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK != hr && !CHECK(hr, DB_S_ERRORSOCCURRED))
{
odtLog << "\t\tCould not create a table with DBPROP_COL_FIXEDLENGTH property value set to VARIANT_FALSE for this column.\n";
}
FreeProperties( &rgColumnDesc[i].cPropertySets, &rgColumnDesc[i].rgPropertySets);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(49)
//*-----------------------------------------------------------------------
// @mfunc Nullable/non nullable columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_49()
{
BOOL fTestRes = TEST_PASS;
DBORDINAL i;
CCol col;
VARIANT defval;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
HRESULT hExpRes = S_OK;
BOOL fSettable = TRUE;
BOOL fSupported = TRUE;
DBPROP *pPropDefault = NULL;
DBPROPSTATUS ulStatus;
ULONG cPropSet, cProp;
if (!SupportedProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN))
{
hExpRes = DB_S_ERRORSOCCURRED;
fSettable = FALSE;
fSupported = FALSE;
}
else
if (!SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN))
fSettable = FALSE;
pTable->CreateTypeColInfo(NativeTypesList, ProviderTypesList);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]);
// try to create a table in which column i is:
// a) nullable
// b) not nullable
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
switch (col.GetNullable())
{
case 0:
odtLog << " (not nullable)\n";
break;
case 1:
odtLog << " (NULLable)\n";
break;
default:
odtLog << "\n";
}
// create a table with a nullable column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED, DB_NULLID, DBPROPSET_COLUMN,
&cPropSet, &cProp);
odtLog << "\tcreate table with a nullable column: ";
// create a table with a column property value set to VARIANT_TRUE for DBPROP_COL_NULLABLE
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
if ( (S_OK == hr && !COMPARE(ulStatus, DBPROPSTATUS_OK))
|| (!fSupported && !COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED))
|| (S_OK != hr && fSettable && !COMPARE(ulStatus, DBPROPSTATUS_BADVALUE))
|| (S_OK != hr && !fSettable && !COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE))
|| (!fSupported && !CHECK(hr, DB_E_ERRORSOCCURRED))
|| (S_OK != hr && !CHECK(hr, DB_E_ERRORSOCCURRED)))
fTestRes = TEST_FAIL;
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
switch (col.GetNullable())
{
case 0:
if (!CHECK(hr, DB_E_ERRORSOCCURRED))
fTestRes = TEST_FAIL;
break;
case 1:
if (!CHECK(hr, S_OK))
fTestRes = TEST_FAIL;
break;
case -1:
if (S_OK != hr && !CHECK(hr, DB_E_ERRORSOCCURRED))
fTestRes = TEST_FAIL;
break;
default:
ASSERT(FALSE);
break;
}
odtLog << ((SUCCEEDED(hr)) ? "CREATED\n" : "INSUCCESS\n");
// create a table with a column property value set to VARIANT_FALSE for DBPROP_COL_NULLABLE
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_REQUIRED, DB_NULLID, DBPROPSET_COLUMN,
&cPropSet, &cProp);
if (SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
{
VariantInit(&defval);
GetDefaultValue(&rgColumnDesc[i], &defval, pTable);
if (SettableProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
SetDefaultProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets,
&defval, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&defval);
}
odtLog << "\tcreate table with a not nullable column\n";
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
ulStatus = rgColumnDesc[i].rgPropertySets[cPropSet].rgProperties[cProp].dwStatus;
FindProperty(
DBPROP_COL_DEFAULT,
DBPROPSET_COLUMN,
rgColumnDesc[i].cPropertySets,
rgColumnDesc[i].rgPropertySets,
&pPropDefault
);
if ( (!pPropDefault || DBPROPSTATUS_OK == pPropDefault->dwStatus)
&& ( (S_OK == hr && !COMPARE(ulStatus, DBPROPSTATUS_OK))
|| (!fSupported && !COMPARE(ulStatus, DBPROPSTATUS_NOTSUPPORTED))
|| (S_OK != hr && fSettable && !COMPARE(ulStatus, DBPROPSTATUS_BADVALUE))
|| (S_OK != hr && !fSettable && !COMPARE(ulStatus, DBPROPSTATUS_NOTSETTABLE))
|| (!fSupported && !CHECK(hr, DB_E_ERRORSOCCURRED))
|| (S_OK != hr && !CHECK(hr, DB_E_ERRORSOCCURRED))))
fTestRes = TEST_FAIL;
if (FAILED(hr))
odtLog << "Could not create a table with DBPROP_COL_NULLABLE property value set to VARIANT_FALSE.\n";
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
delete pTable;
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(50)
//*-----------------------------------------------------------------------
// @mfunc Primary key column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_50()
{
TBEGIN
DBORDINAL i;
CCol col;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hExpRes = S_OK;
if (!SupportedProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN))
hExpRes = DB_S_ERRORSOCCURRED;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// this is to prevent SQL Server limiting the size of
// the index it creates for primary key or unique columns
SetZeroColSize(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
// try to create a table in which column _rgColumnDesc[i].pwszTypeName is:
// a) primary key
// b) not primary key
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// create a table with an primary key column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_PRIMARYKEY,
VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_OPTIONAL);
if (S_OK != (hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL)))
{
CHECK(hr, DB_S_ERRORSOCCURRED);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
// create a table with a column property value set to VARIANT_FALSE for DBPROP_COL_PRIMARYKEY
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_PRIMARYKEY,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
if (1 != col.GetNullable())
hExpRes = DB_S_ERRORSOCCURRED;
if (S_OK != (hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL)))
{
CHECK(hr, DB_S_ERRORSOCCURRED);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(51)
//*-----------------------------------------------------------------------
// @mfunc Unique columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_51()
{
TBEGIN
DBORDINAL i;
CCol col;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fSupported = FALSE;
fSupported = SupportedProperty(DBPROP_COL_DEFAULT, DBPROPSET_COLUMN);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// this is to prevent SQL Server limiting the size of
// the index it creates for primary key or unique columns
SetZeroColSize(rgColumnDesc, cColumnDesc);
for (i=0; i<cColumnDesc; i++)
{
odtLog << "Type " << GetColumnTypeName(&rgColumnDesc[i]) << "\n";
// try to create a table in which column rgColumnDesc[i].pwszTypeName is:
// a) unique
// b) non-unique
// there is no info whether a type can or cannot be unique
col = GetType(GetColumnTypeName(&rgColumnDesc[i]), rgColumnDesc[i].wType);
// create a table with an unique column
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_UNIQUE,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK != hr)
{
odtLog << "Could not create a table with DBPROP_COL_UNIQUE property value set to VARIANT_TRUE for this column.\n";
CHECK(hr, DB_E_ERRORSOCCURRED);
}
else
{
COMPARE(fSupported, TRUE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
// create a table with a column property value set to VARIANT_FALSE for DBPROP_COL_UNIQUE
SetProperty(&rgColumnDesc[i].rgPropertySets, &rgColumnDesc[i].cPropertySets, DBPROP_COL_UNIQUE,
VT_BOOL, (LPVOID)VARIANT_FALSE, DBPROPOPTIONS_OPTIONAL);
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL);
if (S_OK != hr)
{
odtLog << "Could not create a table with DBPROP_COL_UNIQUE property value set to VARIANT_FALSE for this column.\n";
CHECK(hr, DB_S_ERRORSOCCURRED);
}
else
{
COMPARE(fSupported, TRUE);
}
ReleaseAllColumnPropSets(&rgColumnDesc[i], 1);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(52)
//*-----------------------------------------------------------------------
// @mfunc Test conflicting properties
// a column that is both nullable and primary key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_52()
{
TBEGIN
CCol col;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
TESTC_PROVIDER(SettableProperty(DBPROP_COL_NULLABLE, DBPROPSET_COLUMN)
&& SettableProperty(DBPROP_COL_PRIMARYKEY, DBPROPSET_COLUMN));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
// create a table with a column showing contradiction in properties
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets, DBPROP_COL_PRIMARYKEY,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets, DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), DB_E_ERRORSOCCURRED);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(53)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_ABORTPRESERVE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_53()
{
TBEGIN
DBPROPSET *rgPropertySets = NULL;
ULONG cPropertySets = 0;
CCol col;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//SetZeroColSize(rgColumnDesc, cColumnDesc);
TESTC_PROVIDER(SupportedProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET)
&& SettableProperty(DBPROP_ABORTPRESERVE, DBPROPSET_ROWSET));
SetProperty(&rgPropertySets, &cPropertySets, DBPROP_ABORTPRESERVE,
VT_BOOL, (LPVOID)VARIANT_TRUE, DBPROPOPTIONS_REQUIRED, DB_NULLID, DBPROPSET_ROWSET);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
cPropertySets, rgPropertySets), S_OK);
CLEANUP:
FreeProperties( &cPropertySets, &rgPropertySets);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(54)
//*-----------------------------------------------------------------------
// @mfunc Inserting rows after table creation, using the resulting rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_54()
{
IRowsetChange *pIRowsetChange = NULL;
BOOL fTestRes = TEST_FAIL;
BOOL fMayWrite;
DBORDINAL i;
const ULONG nRows = 10;
DBID *pTableID = NULL;
ULONG cPropSets = 0;
DBPROPSET *rgPropSets = NULL;
LONG lUpdateInsert = DBPROPVAL_UP_INSERT;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
CTable *pTable = NULL;
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the provider types list
pTable->CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
pTable->BuildColumnDescs(&rgColumnDesc);
cColumnDesc = pTable->CountColumnsOnTable();
pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//Need to set DBPROP_UPDATABILITY: InsertRow is supported
if ( !SupportedProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET)
|| !SettableProperty(DBPROP_IRowsetChange, DBPROPSET_ROWSET))
{
fTestRes = TEST_SKIPPED;
goto CLEANUP;
}
//Need to set DBPROP_UPDATABILITY: InsertRow is supported
if ( !SupportedProperty(DBPROP_UPDATABILITY, DBPROPSET_ROWSET)
|| !SettableProperty(DBPROP_UPDATABILITY, DBPROPSET_ROWSET))
{
fTestRes = TEST_SKIPPED;
goto CLEANUP;
}
::SetProperty( DBPROP_UPDATABILITY, DBPROPSET_ROWSET, &cPropSets, &rgPropSets,
DBTYPE_I4, (LPVOID)&lUpdateInsert);
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc, IID_IRowsetChange,
cPropSets, rgPropSets, &pTableID, (IUnknown**)&pIRowsetChange), S_OK);
fTestRes = TEST_PASS;
// find out if one can write to that table
pTable->SetTableID(*pTableID);
pTable->MayWrite(&fMayWrite);
for (i=0; i<nRows; i++)
{
m_hr = Insert(0, pIRowsetChange, 0, NULL, pTable);
if (DB_E_NOTSUPPORTED != m_hr)
{
if (!CHECK(m_hr, S_OK))
fTestRes = TEST_FAIL;
}
else
fTestRes = TEST_SKIPPED;
}
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
if (pTableID)
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
FreeProperties( &cPropSets, &rgPropSets);
delete pTable;
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(55)
//*-----------------------------------------------------------------------
// @mfunc Delete rows in the created rowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_55()
{
IRowsetChange *pIRowsetChange = NULL;
IRowset *pIRowset = NULL;
BOOL fTestRes = TEST_FAIL;
ULONG i, nSuccess;
const ULONG nRows = 10;
const int nProps = 3;
DBPROPSET rgPropSets[1];
DBPROP rgProperties[nProps];
HROW *rghRow = NULL;
DBCOUNTITEM cRowsObtained = 0;
DBROWSTATUS rgRowStatus[nRows];
DBID *pTableID = NULL;
BOOL fMayWrite;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
CTable *pTable = NULL;
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the provider types list
pTable->CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
pTable->BuildColumnDescs(&rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc=pTable->CountColumnsOnTable());
pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProperties), rgProperties, DBPROPSET_ROWSET)
FILL_PROP(rgProperties[0], DBPROP_IRowsetChange, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
FILL_PROP(rgProperties[1], DBPROP_OWNINSERT, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED)
FILL_PROP(rgProperties[2], DBPROP_OWNUPDATEDELETE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc, IID_IRowsetChange,
NUMELEM(rgPropSets), rgPropSets, &pTableID, (IUnknown**)&pIRowsetChange), S_OK);
pTable->SetTableID(*pTableID);
pTable->MayWrite(&fMayWrite);
for (i=0; i<nRows; i++)
{
m_hr = Insert(0, pIRowsetChange, 0, NULL, pTable);
if (DB_E_NOTSUPPORTED == m_hr)
{
odtLog << "IRowsetChange->Insert() is not supported\n";
fTestRes = TEST_SKIPPED;
goto CLEANUP;
}
else
TESTC_(m_hr, S_OK);
}
// get a pointer to IRoewset interface
if (!VerifyInterface(pIRowsetChange, IID_IRowset, ROWSET_INTERFACE, (IUnknown**)&pIRowset))
{
odtLog << "could not get IRowsetChange\n";
goto CLEANUP;
}
m_hr = pIRowset->RestartPosition(NULL);
if (!CHECK(m_hr = pIRowset->GetNextRows(
0, 0, // hChapter & lRowsOffset
nRows, // number of rows to be retrieved
&cRowsObtained, //number of rows actually get
&rghRow // array of handlers to rows
), S_OK) || nRows != cRowsObtained)
{
odtLog << "insuccess on IRowset::GetNextRows\n";
goto CLEANUP;
}
TESTC_(m_hr = pIRowsetChange->DeleteRows(0, cRowsObtained, rghRow, rgRowStatus), S_OK);
for (i=nSuccess=0; i<nRows; i++)
if (DBROWSTATUS_S_OK == rgRowStatus[i])
nSuccess ++;
if (nSuccess != nRows)
odtLog << "delete succeeded for " << nRows-nSuccess << " rows out of " << nRows << "\n";
else
fTestRes = TEST_PASS;
CLEANUP:
if (cRowsObtained)
CHECK(m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL), S_OK);
PROVIDER_FREE(rghRow);
SAFE_RELEASE(pIRowsetChange);
SAFE_RELEASE(pIRowset);
if (pTableID)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
}
delete pTable;
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(56)
//*-----------------------------------------------------------------------
// @mfunc Aggregation, ask for IID_IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_56()
{
TBEGIN
HRESULT hr;
DBID *pTableID = NULL;
CAggregate Aggregate(m_pIOpenRowset);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TEST2C_(hr = CreateAndCheckTable(m_pITableDefinition, &Aggregate, NULL, cColumnDesc, rgColumnDesc,
IID_IUnknown, 0, NULL, &pTableID, (IUnknown**)&Aggregate.m_pIUnkInner),
S_OK, DB_E_NOAGGREGATION);
TESTC_PROVIDER(S_OK == hr);
// Verify Aggregation for this rowset...
TESTC(Aggregate.VerifyAggregationQI(hr, IID_IRowset));
CLEANUP:
Aggregate.ReleaseInner();
// checkings, etc
CHECK(DropTableAndCheck(pTableID), pTableID? S_OK: E_INVALIDARG);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(57)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_COMMITPRESERVE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_57()
{
TBEGIN
DBPROPID rgPropID=DBPROP_COMMITPRESERVE;
COMPARE(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_TRUE,
(struct _GUID*)&IID_IRowsetInfo), TRUE);
TESTC(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_FALSE,
(struct _GUID*)&IID_IRowsetInfo));
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(58)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_OWNINSERT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_58()
{
TBEGIN
DBPROPID rgPropID=DBPROP_OWNINSERT;
COMPARE(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_TRUE,
(struct _GUID*)&IID_IRowsetInfo), TRUE);
TESTC(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_FALSE,
(struct _GUID*)&IID_IRowsetInfo));
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(59)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_BOOKMARKS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_59()
{
TBEGIN
DBPROPID rgPropID=DBPROP_BOOKMARKS;
COMPARE(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_TRUE,
(struct _GUID*)&IID_IRowsetInfo), TRUE);
TESTC(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_FALSE,
(struct _GUID*)&IID_IRowsetInfo));
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(60)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_CANHOLDROWS
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_60()
{
TBEGIN
DBPROPID rgPropID=DBPROP_CANHOLDROWS;
COMPARE(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_TRUE,
(struct _GUID*)&IID_IRowsetInfo), TRUE);
TESTC(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_FALSE,
(struct _GUID*)&IID_IRowsetInfo));
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(61)
//*-----------------------------------------------------------------------
// @mfunc Create a table and ask for a rowset, setting DBPROP_MAYWRITECOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_61()
{
TBEGIN
DBPROPID rgPropID=DBPROP_MAYWRITECOLUMN;
COMPARE(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_TRUE,
(struct _GUID*)&IID_IRowsetInfo), TRUE);
TESTC(CreateWithOneRowsetProps(rgPropID, VT_BOOL, (LPVOID)VARIANT_FALSE,
(struct _GUID*)&IID_IRowsetInfo));
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(62)
//*-----------------------------------------------------------------------
// @mfunc Ask for a rowset mandatory/optional interface when table creation => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_62()
{
BOOL fTestRes = TEST_FAIL;
IUnknown *pIRowset = NULL;
DBID *pTableID = NULL;
BOOL fMayWrite;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
CTable *pTable = NULL;
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the provider types list
pTable->CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
pTable->BuildColumnDescs(&rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc=pTable->CountColumnsOnTable());
pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
odtLog << "CreateTable and ask for a pointer to IRowset (mandatory)\n";
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
0, NULL), S_OK);
odtLog << "CreateTable and ask for a pointer to IRowsetChange (optional)\n";
CHECK(hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetChange, 0, NULL, &pTableID, (IUnknown**)&pIRowset), S_OK);
// try to use the IRowsetChange interface to insert a row
if (SUCCEEDED(hr))
{
pTable->SetTableID(*pTableID);
pTable->MayWrite(&fMayWrite);
m_hr = Insert(0, (IRowsetChange*)pIRowset, 0, NULL, pTable);
if (DB_E_NOTSUPPORTED != m_hr)
{
TESTC_(m_hr, S_OK);
}
else
{
fTestRes = TEST_SKIPPED;
goto CLEANUP;
}
}
fTestRes = TEST_PASS;
CLEANUP:
// checkings, etc
SAFE_RELEASE(pIRowset);
if (pTableID)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
}
delete pTable;
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
unsigned TCCreateTable::MyThreadProc(ULONG i)
{
DBCOLUMNDESC *rgColumnDesc = NULL;
DBID TableID;
DBID *pTableID = NULL;
HRESULT hr;
if (i>= nThreads)
return 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, m_cColumnDesc);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_rgName[i];
Sleep(0); // switch the context
hr = m_pITableDefinition->CreateTable(NULL, m_rgName[i]? &TableID: NULL,
m_cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL,
m_rgName[i] ? NULL: &pTableID, NULL);
Sleep(0); // switch the context
m_rgResult[i] = hr;
if (!m_rgName[i] && pTableID && DBKIND_NAME == pTableID->eKind)
{
m_rgName[i] = pTableID->uName.pwszName;
SAFE_FREE(pTableID);
}
else
ReleaseDBID(pTableID);
ReleaseColumnDesc(rgColumnDesc, m_cColumnDesc);
return 1;
} //TCCreateTable::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(63)
//*-----------------------------------------------------------------------
// @mfunc threads on different tables
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_63()
{
TBEGIN
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
WCHAR number[3];
LPWSTR pwszBaseName = NULL;
DBID TableID;
odtLog << "All table names are generated by user\n";
m_pTable->MakeTableName(NULL);
pwszBaseName = m_pTable->GetTableName();
for (i=0; i< nThreads; i++)
{
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
m_rgResult[i] = E_FAIL;
m_rgName[i] = (WCHAR*)PROVIDER_ALLOC((3+wcslen(pwszBaseName))*sizeof(WCHAR));
ASSERT(m_rgName[i]);
wcscpy(m_rgName[i], pwszBaseName);
swprintf(number, L"%02d", i);
wcscat(m_rgName[i], number);
}
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
TableID.eKind = DBKIND_NAME;
for (i=0; i<nThreads; i++)
{
if (CHECK(m_rgResult[i], S_OK))
{
TableID.uName.pwszName = m_rgName[i];
CHECK(DropTableAndCheck(&TableID), S_OK);
}
}
odtLog << "All table names are provider generated\n";
for (i=0; i< nThreads; i++)
{
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
m_rgResult[i] = E_FAIL;
m_rgName[i] = NULL;
}
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
CHECK(m_rgResult[i], S_OK);
CLEANUP:
TableID.eKind = DBKIND_NAME;
for (i=0; i<nThreads; i++)
{
TableID.uName.pwszName = m_rgName[i];
if (SUCCEEDED(m_rgResult[i]))
CHECK(DropTableAndCheck(&TableID), S_OK);
PROVIDER_FREE(m_rgName[i]);
}
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(64)
//*-----------------------------------------------------------------------
// @mfunc threads on the same table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_64()
{
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
BOOL fTestResult = TEST_FAIL;
ULONG i, nS_OK, nDB_E_DUPLICATETABLEID;
LPWSTR pwszBaseName = NULL;
DBID TableID;
m_pTable->MakeTableName(NULL);
pwszBaseName = m_pTable->GetTableName();
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = E_FAIL;
m_rgName[i] = pwszBaseName;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// creates a table, build rgColumnDesc by it
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=nS_OK=nDB_E_DUPLICATETABLEID=0; i<nThreads; i++)
{
if (m_rgResult[i] == S_OK)
nS_OK++;
else if (CHECK(m_rgResult[i], DB_E_DUPLICATETABLEID))
nDB_E_DUPLICATETABLEID++;
else
{
odtLog << "Thread " << i << ": unexpected result " << m_rgResult[i] << "\n";
goto CLEANUP;
}
}
TESTC(nS_OK == 1 && nDB_E_DUPLICATETABLEID == nThreads-1);
fTestResult = TEST_PASS;
CLEANUP:
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = pwszBaseName;
CHECK(DropTableAndCheck(&TableID), S_OK);
return fTestResult;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(65)
//*-----------------------------------------------------------------------
// @mfunc try all interfaces on rowset that can be returned
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_65()
{
TBEGIN
const ULONG nInterfaces = 19; // number of total interfaces
const ULONG nMandatoryInterfaces = 6; // the number of mandatory interfaces
const IID* rgRIIDInterfaces[nInterfaces] = {&IID_IUnknown, &IID_IAccessor, &IID_IColumnsInfo,
&IID_IConvertType, &IID_IRowset, &IID_IRowsetInfo, &IID_IChapteredRowset,
&IID_IColumnsRowset, &IID_IConnectionPointContainer, &IID_IDBAsynchStatus,
&IID_IRowsetChange, &IID_IRowsetFind, &IID_IRowsetIdentity, &IID_IRowsetLocate,
&IID_IRowsetResynch, &IID_IRowsetScroll, &IID_IRowsetUpdate, &IID_IRowsetView,
&IID_ISupportErrorInfo};
LPWSTR rgInterfaceNames[nInterfaces] = {L"IUnknown", L"IAccessor", L"IColumnsInfo",
L"IConvertType", L"IRowset", L"IRowsetInfo", L"IChapteredRowset",
L"IColumnsRowset", L"IConnectionPointContainer", L"IDBAsynchStatus",
L"IRowsetChange", L"IRowsetFind", L"IRowsetIdentity", L"IRowsetLocate",
L"IRowsetResynch", L"IRowsetScroll", L"IRowsetUpdate", L"IRowsetView",
L"ISupportErrorInfo"};
const DBPROPID rgInterfaceID[nInterfaces-1] = {DBPROP_IAccessor, DBPROP_IColumnsInfo,
DBPROP_IConvertType, DBPROP_IRowset, DBPROP_IRowsetInfo, DBPROP_IChapteredRowset,
DBPROP_IColumnsRowset, DBPROP_IConnectionPointContainer, DBPROP_IDBAsynchStatus,
DBPROP_IRowsetChange, DBPROP_IRowsetFind, DBPROP_IRowsetIdentity, DBPROP_IRowsetLocate,
DBPROP_IRowsetResynch, DBPROP_IRowsetScroll, DBPROP_IRowsetUpdate, DBPROP_IRowsetView,
DBPROP_ISupportErrorInfo};
// BOOL fTestRes = TEST_PASS;
ULONG i, j;
IUnknown *pRowset = NULL;
IUnknown *pIUnknown = NULL;
DBPROPSET rgPropertySets[2];
DBPROP rgProperties[nInterfaces-1];
DBPROP rgProp2[1];
DBID *pTableID = NULL;
HRESULT hr;
HRESULT hRes = S_OK;
HRESULT hExpectedRes = S_OK;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
BOOL fRetrieve = true;
BOOL fPropSupported;
FILL_PROP_SET(rgPropertySets[0], NUMELEM(rgProperties), rgProperties, DBPROPSET_ROWSET);
for (i=0; i<nInterfaces-1; i++)
{
FILL_PROP(rgProperties[i], rgInterfaceID[i], VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
if (!SupportedProperty(rgInterfaceID[i], DBPROPSET_ROWSET))
hRes = DB_S_ERRORSOCCURRED;
}
FILL_PROP_SET(rgPropertySets[1], NUMELEM(rgProp2), rgProp2, DBPROPSET_ROWSET);
FILL_PROP(rgProp2[0], DBPROP_ISequentialStream, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
if (!SupportedProperty(DBPROP_ISequentialStream, DBPROPSET_ROWSET))
hRes = DB_S_ERRORSOCCURRED;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
for (i=0; i<nInterfaces; i++)
{
odtLog << "\t" << rgInterfaceNames[i] << ((i<nMandatoryInterfaces)? "(mandatory)\n" : "\n");
PRVTRACE(L"TCCreateTable::Variation_65(): iteration %d (%s)\n",
i, ((i>0) ? rgInterfaceNames[i] : L"IUnknown"));
fPropSupported = (i>0)? SupportedProperty(rgInterfaceID[i-1], DBPROPSET_ROWSET): TRUE;
hExpectedRes = ((i>0) && !fPropSupported)? E_NOINTERFACE: hRes;
// This interface is only supported if user sets DBPROP_ROWSET_ASYNCH in the
// rowset properties otherwise its unsupported.
if (i>0 && rgInterfaceID[i-1] == DBPROP_IDBAsynchStatus)
{
fPropSupported = FALSE;
hExpectedRes = E_NOINTERFACE;
}
// if the interface is mandatory, it has to be supported
// note that there is not a DBPROP_IUnknown, so the condition is i>nMandatoryInterfaces
COMPARE(i==0 || fPropSupported || i>=nMandatoryInterfaces, TRUE);
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc,
*rgRIIDInterfaces[i], 0, NULL,
FALSE), fPropSupported? S_OK: E_NOINTERFACE);
pRowset = NULL;
CHECK(hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
*rgRIIDInterfaces[i], NUMELEM(rgPropertySets), rgPropertySets,
&pTableID, &pRowset), hExpectedRes);
if (S_OK != hr && DB_S_ERRORSOCCURRED != hr)
{
if (i<nMandatoryInterfaces)
{
odtLog << "could not get the mandatory interface " << rgInterfaceNames[i] << "\n";
COMPARE(TRUE, FALSE);
}
}
else
{
// try to get all the other interfaces
if (pRowset)
{
fRetrieve = CHECK(pRowset->QueryInterface(IID_IUnknown,
(void**)&pIUnknown), S_OK) ? fRetrieve: FALSE;
SAFE_RELEASE(pIUnknown);
// all the other interfaces considered
for (j=1; j<nInterfaces; j++)
{
odtLog << "\tTesting: " << rgInterfaceNames[j] << "\n";
if ( (j<nMandatoryInterfaces)
&& ( !COMPARE(rgProperties[j-1].dwStatus, DBPROPSTATUS_OK)
|| !CHECK(pRowset->QueryInterface(*rgRIIDInterfaces[j], (void**)&pIUnknown), S_OK)))
{
odtLog << "Could not retrieve mandatory interface " << rgInterfaceNames[j] << "\n";
continue;
}
SAFE_RELEASE(pIUnknown);
fRetrieve = TRUE;
// the interface should be retrievable if and only if the propstatus is ok
if (DBPROPSTATUS_OK == rgProperties[j-1].dwStatus)
{
fRetrieve = CHECK(pRowset->QueryInterface(*rgRIIDInterfaces[j],
(void**)&pIUnknown), S_OK) ? fRetrieve: FALSE;
SAFE_RELEASE(pIUnknown);
}
else
{
fRetrieve = CHECK(pRowset->QueryInterface(*rgRIIDInterfaces[j],
(void**)&pIUnknown), E_NOINTERFACE) ? fRetrieve: FALSE;
}
// check on prop status
if (SupportedProperty(rgInterfaceID[j-1], DBPROPSET_ROWSET))
{
if (SettableProperty(rgInterfaceID[j-1], DBPROPSET_ROWSET))
fRetrieve = ((DBPROPSTATUS_NOTSET != rgProperties[j-1].dwStatus
&& !COMPARE(rgProperties[j-1].dwStatus, DBPROPSTATUS_OK))) ? FALSE: fRetrieve;
else
fRetrieve = (DBPROPSTATUS_OK != rgProperties[j-1].dwStatus
&& !COMPARE(rgProperties[j-1].dwStatus, DBPROPSTATUS_NOTSETTABLE)) ? FALSE: fRetrieve;
}
else
{
fRetrieve = (!COMPARE(rgProperties[j-1].dwStatus, DBPROPSTATUS_NOTSUPPORTED))? FALSE: fRetrieve;
}
if (!fRetrieve)
{
odtLog << "ERROR: retrieving interface " << rgInterfaceNames[j] << "\n";
}
}
}
}
if (pRowset)
SAFE_RELEASE(pRowset);
if (pTableID)
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
}
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(66)
//*-----------------------------------------------------------------------
// @mfunc create with a table property => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_66()
// just try the creation of a table with the specified property
// there is not any method to retrieve the property of the table
{
TBEGIN
DBPROPSET rgPropSets[1];
DBPROP rgProp[1];
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID TableID;
BOOL fSupported;
BOOL fSettable;
BOOL fValidate;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
fSupported = SupportedProperty(DBPROP_TBL_TEMPTABLE, DBPROPSET_TABLE);
fSettable = SettableProperty(DBPROP_TBL_TEMPTABLE, DBPROPSET_TABLE);
fValidate = fSettable || !fSupported;
hr = fSettable? S_OK : DB_E_ERRORSOCCURRED;
odtLog << "Property is REQUIRED\n";
// temp table, TableID generated by provider
odtLog << "\tProvider generated TableID\n";
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, NUMELEM(rgPropSets), rgPropSets);
if (fValidate && fSettable || S_OK == hr)
{
CHECK(hr, S_OK);
COMPARE(rgProp[0].dwStatus, DBPROPSTATUS_OK);
}
else
{
CHECK(hr, DB_E_ERRORSOCCURRED);
if (fSupported)
{ COMPARE(DBPROPSTATUS_NOTSETTABLE == rgProp[0].dwStatus, TRUE);}
else
{ COMPARE(DBPROPSTATUS_NOTSUPPORTED == rgProp[0].dwStatus, TRUE);}
}
// perm table, TableID generated by provider
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
hr = (S_OK!=hr)? DB_E_ERRORSOCCURRED : S_OK;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), hr);
// temp table, consumer generated TableID
odtLog << "\tConsumer generated TableID\n";
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = wcsDuplicate(m_pTable->GetTableName());
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
hr = CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, NUMELEM(rgPropSets), rgPropSets);
// perm table, consumer generated TableID
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
hr = (S_OK!=hr)? DB_E_ERRORSOCCURRED : S_OK;
CHECK(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), hr);
hr = fSettable? S_OK : DB_S_ERRORSOCCURRED;
odtLog << "Property is OPTIONAL\n";
// temp table, TableID generated by provider
odtLog << "\tProvider generated TableID\n";
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
TEST2C_(hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), S_OK, DB_S_ERRORSOCCURRED);
// perm table, TableID generated by provider
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_FALSE, DBPROPOPTIONS_OPTIONAL);
hr = (S_OK!=hr)? DB_S_ERRORSOCCURRED : S_OK;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), hr);
// temp table, consumer generated TableID
odtLog << "\tConsumer generated TableID\n";
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = wcsDuplicate(m_pTable->GetTableName());
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
TEST2C_(hr = CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), S_OK, DB_S_ERRORSOCCURRED);
// perm table, consumer generated TableID
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_FALSE, DBPROPOPTIONS_OPTIONAL);
hr = (S_OK!=hr)? DB_S_ERRORSOCCURRED : S_OK;
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), hr);
CLEANUP:
// checkings, etc
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(67)
//*-----------------------------------------------------------------------
// @mfunc create a table and update a row, using the rowset interface got => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_67()
{
IRowsetChange *pIRowsetChange = NULL;
IRowset *pIRowset = NULL;
IAccessor *pIAccessor = NULL;
BOOL fTestRes = TEST_FAIL;
ULONG i;
const ULONG nInsertRows = 10;
BOOL fMayWrite;
const ULONG nRows = 3;
DBPROPSET rgPropSets[1];
const ULONG nProps = 3;
DBPROP rgProperties[nProps];
HROW *rghRow = NULL;
DBCOUNTITEM cRowsObtained = 0;
HACCESSOR hAccessor = NULL;
BYTE *pData = NULL;
DBCOUNTITEM cBindings = 0;
DBBINDING *rgBindings = NULL;
const LONG cColsToBind = 1;
LONG_PTR rgColsToBind[cColsToBind];
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
CTable *pTable = NULL;
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// get the provider types list
pTable->CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
pTable->BuildColumnDescs(&rgColumnDesc);
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc=pTable->CountColumnsOnTable());
pTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProperties), rgProperties, DBPROPSET_ROWSET);
FILL_PROP(rgProperties[0], DBPROP_IRowsetChange, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
FILL_PROP(rgProperties[1], DBPROP_OWNINSERT, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
FILL_PROP(rgProperties[2], DBPROP_OWNUPDATEDELETE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL);
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc, IID_IRowsetChange, 1, rgPropSets,
&pTableID, (IUnknown**)&pIRowsetChange), S_OK);
pTable->SetTableID(*pTableID);
pTable->MayWrite(&fMayWrite);
for (i=0; i<nInsertRows; i++)
{
m_hr = Insert(0, pIRowsetChange, 0, NULL, pTable);
if (DB_E_NOTSUPPORTED != m_hr)
{
TESTC_(m_hr, S_OK);
}
else
{
fTestRes = TEST_SKIPPED;
goto CLEANUP;
}
}
// get a pointer to IRoewset interface
if (!VerifyInterface(pIRowsetChange, IID_IRowset, ROWSET_INTERFACE, (IUnknown**)&pIRowset))
{
odtLog << "could not get IRowsetChange\n";
goto CLEANUP;
}
if (!VerifyInterface(pIRowset, IID_IAccessor, ROWSET_INTERFACE, (IUnknown**)&pIAccessor))
{
odtLog << "could not get IAccessor\n";
goto CLEANUP;
}
m_hr = pIRowset->RestartPosition(NULL);
if (!CHECK(m_hr = pIRowset->GetNextRows(0, 0, // hChapter & lRowsOffset
nRows, // number of rows to be retrieved
&cRowsObtained, //number of rows actually get
&rghRow // array of handlers to rows
), S_OK) || nRows != cRowsObtained)
{
odtLog << "insuccess on IRowset::GetNextRows\n";
goto CLEANUP;
}
rgColsToBind[0] = 1;
if (!CHECK(m_hr = GetAccessorAndBindings(pIRowset, // pIUnknRowsetObject
DBACCESSOR_ROWDATA, // accessor flags
&hAccessor, &rgBindings, &cBindings, NULL, // accessor handler, array and number of bindings created
DBPART_VALUE |DBPART_STATUS |DBPART_LENGTH, // types of bindings to do
USE_COLS_TO_BIND_ARRAY, // eColsByRef specifies that cols to be bind
//are gien as an array
FORWARD, // eBindingOrder
NO_COLS_BY_REF, // eColsByRef
NULL, NULL,
NULL, DBTYPE_EMPTY, // ppStringsBufferOut & dwModifier
cColsToBind, rgColsToBind), S_OK))
{
odtLog << "problems getting accessor and bindings\n";
goto CLEANUP;
}
// Fill buffer with appropriate data for insert of this row number
TESTC_(m_hr = FillInputBindings(
pTable,
DBACCESSOR_ROWDATA,
cBindings,
rgBindings,
&pData,
37,
0,
NULL),S_OK);
if (!CHECK(m_hr = pIRowsetChange->SetData(rghRow[0], hAccessor, pData), S_OK))
{
odtLog << "could not update the row\n";
goto CLEANUP;
}
fTestRes = TEST_PASS;
CLEANUP:
if (pIAccessor && hAccessor)
{
CHECK(m_hr = pIAccessor->ReleaseAccessor(hAccessor, NULL), S_OK);
}
SAFE_RELEASE(pIAccessor);
if (pIRowset)
CHECK(m_hr = pIRowset->ReleaseRows(cRowsObtained, rghRow, NULL, NULL, NULL), S_OK);
PROVIDER_FREE(rghRow);
SAFE_RELEASE(pIRowsetChange);
SAFE_RELEASE(pIRowset);
if (pTableID)
{
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
}
delete pTable;
FreeAccessorBindings(cBindings, rgBindings);
PROVIDER_FREE(pData);
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(68)
//*-----------------------------------------------------------------------
// @mfunc Fully Qualified Table Name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_68()
{
BOOL fTestRes = TEST_FAIL;
DBID TableID;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
WCHAR *pwszTableName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CTable *pTable = NULL;
// create a regular table
pTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
TESTC(NULL != pTable);
TESTC_(pTable->CreateTable(0, 0), S_OK);
pwszTableName = pTable->GetTableName();
TableID.eKind = DBKIND_NAME;
TESTC(GetCatalogSchemaNames(pwszTableName, &pwszCatalogName, &pwszSchemaName, pTable));
//Construct a fully Qualified TableName...
TESTC_(pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, pwszTableName, &pwszQualTableName),S_OK);
TableID.uName.pwszName = pwszQualTableName;
// get rid of the previous table; keep info about "the empty shell"
m_pITableDefinition->DropTable(&pTable->GetTableID());
// create the table with the qualified name
pTable->BuildColumnDescs(&rgColumnDesc);
pTable->SetColumnDesc(rgColumnDesc, cColumnDesc=pTable->CountColumnsOnTable());
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
fTestRes = TEST_PASS;
CLEANUP:
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
pTable->DropTable();
delete pTable;
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(69)
//*-----------------------------------------------------------------------
// @mfunc Quoted table name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_69()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
m_pTable->MakeTableName(NULL);
m_pTable->GetQuotedName(m_pTable->GetTableName(), &TableID.uName.pwszName);
TESTC_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK);
CLEANUP:
ReleaseDBID(&TableID, FALSE);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(70)
//*-----------------------------------------------------------------------
// @mfunc Aggregation, non IID_IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_70()
{
TBEGIN
DBID *pTableID = NULL;
CAggregate Aggregate(m_pIOpenRowset);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TESTC_(CreateAndCheckTable(m_pITableDefinition, &Aggregate, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetChange, 0, NULL, &pTableID, (IUnknown**)&Aggregate.m_pIUnkInner),
DB_E_NOAGGREGATION);
// Verrify Aggregation for this rowset...
TESTC(NULL == Aggregate.m_pIUnkInner);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
Aggregate.ReleaseInner();
// checkings, etc
DropTableAndCheck(pTableID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(71)
//*-----------------------------------------------------------------------
// @mfunc Aggregation -> IRowsetInfo::GetReferencedRowset
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_71()
{
TBEGIN
HRESULT hr;
DBID *pTableID = NULL;
CAggregate Aggregate(m_pIOpenRowset);
IRowsetInfo *pIRowsetInfo = NULL;
IUnknown *pIAggregate = NULL;
IUnknown *pIUnkOuter = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
ULONG cPropSet = 0;
DBPROPSET *prgPropSet = NULL;
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// create a table and open a bookmark rowset on it
if (SettableProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET))
{
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_ROWSET);
FILL_PROP(rgProp[0], DBPROP_BOOKMARKS, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
prgPropSet = rgPropSet;
cPropSet = 1;
}
TEST2C_(hr = CreateAndCheckTable(m_pITableDefinition, &Aggregate, NULL, cColumnDesc, rgColumnDesc, IID_IUnknown, cPropSet, prgPropSet,
&pTableID, (IUnknown**)&Aggregate.m_pIUnkInner), S_OK, DB_E_NOAGGREGATION);
TEST_PROVIDER(S_OK == hr);
//Verify Aggregation for this rowset...
TESTC(Aggregate.VerifyAggregationQI(hr, IID_IRowsetInfo, (IUnknown**)&pIRowsetInfo));
//Verify we are hooked up...
//This call we are using the Rowset and asking for IID_IAggregate,
//which is the outer object and should succeed!!! Kind of cool huh!
hr = pIRowsetInfo->GetReferencedRowset(0, IID_IAggregate, (IUnknown**)&pIAggregate);
TESTC(hr==S_OK || hr==DB_E_BADORDINAL ||hr==DB_E_NOTAREFERENCECOLUMN);
if(hr==DB_E_NOTAREFERENCECOLUMN || hr==DB_E_BADORDINAL)
TESTC(!GetProperty(DBPROP_BOOKMARKS, DBPROPSET_ROWSET, Aggregate.m_pIUnkInner, VARIANT_TRUE));
TESTC_PROVIDER(hr==S_OK);
//Now make sure the Rowset QI for IUnknown give me the outer
TESTC_(hr = pIRowsetInfo->GetReferencedRowset(0, IID_IUnknown, (IUnknown**)&pIUnkOuter),S_OK);
TESTC(VerifyEqualInterface(pIAggregate, pIUnkOuter));
CLEANUP:
SAFE_RELEASE(pIAggregate);
SAFE_RELEASE(pIRowsetInfo);
SAFE_RELEASE(pIUnkOuter);
Aggregate.ReleaseInner();
// checkings, etc
CHECK(DropTableAndCheck(pTableID), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(72)
//*-----------------------------------------------------------------------
// @mfunc Agg session -> IRowsetInfo::GetSpecification
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_72()
{
CAggregate Aggregate(g_pIDBCreateSession);
ULONG fTestRes = TEST_FAIL;
IRowsetInfo *pIRowsetInfo = NULL;
ITableDefinition *pITableDefinition = NULL;
IUnknown *pIAggregate = NULL;
ULONG ulRefCountBefore;
ULONG ulRefCountAfter;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
//Aggregation
HRESULT hr = CreateNewSession(g_pIDBInitialize, IID_IUnknown, (IUnknown**)&Aggregate.m_pIUnkInner, &Aggregate);
TEST_PROVIDER(S_OK == hr);
//Verify Aggregation for this session...
TESTC(Aggregate.VerifyAggregationQI(hr, IID_ITableDefinition, (IUnknown**)&pITableDefinition));
//Now Create the Rowset
ulRefCountBefore = Aggregate.GetRefCount();
// create a table and open a bookmark rowset on it
TESTC_(CreateAndCheckTable(pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetInfo, 0, NULL, &pTableID, (IUnknown**)&pIRowsetInfo), S_OK);
ulRefCountAfter = Aggregate.GetRefCount();
//GetSpecification
TEST2C_(hr = pIRowsetInfo->GetSpecification(IID_IAggregate, (IUnknown**)&pIAggregate),S_OK,S_FALSE);
if(hr==S_OK)
{
TESTC(VerifyEqualInterface(pIAggregate, pITableDefinition));
//Verify the child correctly addref'd the parent outer.
//The is an absolute requirement that the child keep the parent outer alive.
//If it doesn't addref the outer, the outer can be released externally since
//its not being used anymore due to the fact the outer controls the refcount
//of the inner. Many providers incorrectly addref the inner, which does nothing
//but guareentee the inner survives, but the inner will delegate to the outer
//and crash since it no longer exists...
TCOMPARE_(ulRefCountAfter > ulRefCountBefore);
}
else
{
TWARNING(L"IRowsetInfo::GetSpecification unable to retrieve Parent object!");
}
fTestRes = TEST_PASS;
CLEANUP:
SAFE_RELEASE(pIAggregate);
SAFE_RELEASE(pIRowsetInfo);
Aggregate.ReleaseInner();
// checkings, etc
if (pITableDefinition)
CHECK(DropTableAndCheck(pTableID, pITableDefinition), S_OK);
SAFE_RELEASE(pITableDefinition);
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(73)
//*-----------------------------------------------------------------------
// @mfunc Table -> Agg ColumnRowset, ask for non IID_IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_73()
{
TBEGIN
DBID *pTableID = NULL;
CAggregate Aggregate(m_pIOpenRowset);
IRowset *pIRowset = NULL;
IColumnsRowset *pIColumnsRowset = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetSettableProperty(DBPROP_IColumnsRowset, DBPROPSET_ROWSET, &cPropSet, &rgPropSet);
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowset, cPropSet, rgPropSet, &pTableID, (IUnknown**)&pIRowset), S_OK);
//Obtain the ColumnsRowset interface [OPTIONAL] interface
TESTC_PROVIDER(VerifyInterface(pIRowset, IID_IColumnsRowset, ROWSET_INTERFACE, (IUnknown**)&pIColumnsRowset));
//Try to obtain anything but IID_IUnknown.
//This should fail, this is a requirement for COM Aggregation...
TESTC_(pIColumnsRowset->GetColumnsRowset(&Aggregate, 0, NULL, IID_IRowset, 0, NULL,
(IUnknown**)&Aggregate.m_pIUnkInner),DB_E_NOAGGREGATION);
//Inner object cannot RefCount the outer object - COM rule for CircularRef
TESTC(Aggregate.GetRefCount() == 1);
TESTC(Aggregate.m_pIUnkInner == NULL);
CLEANUP:
SAFE_RELEASE(pIColumnsRowset);
SAFE_RELEASE(pIRowset);
Aggregate.ReleaseInner();
DropTableAndCheck(pTableID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(74)
//*-----------------------------------------------------------------------
// @mfunc Table -> Agg ColumnRowset, ask for IID_IUnknown
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_74()
{
TBEGIN
HRESULT hr;
DBID *pTableID = NULL;
CAggregate Aggregate(m_pIOpenRowset);
IRowset *pIRowset = NULL;
IColumnsRowset *pIColumnsRowset = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetSettableProperty(DBPROP_IColumnsRowset, DBPROPSET_ROWSET, &cPropSet, &rgPropSet);
TEST2C_(hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowset, cPropSet, rgPropSet, &pTableID, (IUnknown**)&pIRowset), S_OK, DB_E_ERRORSOCCURRED);
if (DB_E_ERRORSOCCURRED == hr)
TESTC(!GetProperty(DBPROP_IColumnsRowset, DBPROPSET_ROWSET, pIRowset, VARIANT_TRUE));
TESTC_PROVIDER(S_OK == hr);
//Obtain the ColumnsRowset interface [OPTIONAL] interface
TESTC_PROVIDER(VerifyInterface(pIRowset, IID_IColumnsRowset, ROWSET_INTERFACE, (IUnknown**)&pIColumnsRowset));
//Try to obtain IID_IUnknown.
TEST2C_(hr = pIColumnsRowset->GetColumnsRowset(&Aggregate, 0, NULL, IID_IUnknown, 0, NULL,
(IUnknown**)&Aggregate.m_pIUnkInner), S_OK, DB_E_NOAGGREGATION);
TESTC_PROVIDER(S_OK == hr);
//Verify Aggregation for this session...
TESTC(Aggregate.VerifyAggregationQI(hr, IID_IRowset));
CLEANUP:
SAFE_RELEASE(pIColumnsRowset);
SAFE_RELEASE(pIRowset);
Aggregate.ReleaseInner();
// checkings, etc
DropTableAndCheck(pTableID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(75)
//*-----------------------------------------------------------------------
// @mfunc Table -> Agg ColumnRowset -> IRowsetInfo::GetSpecification
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_75()
{
TBEGIN
CAggregate Aggregate(m_pIOpenRowset);
ULONG fTestRes = TEST_FAIL;
IRowset *pIRowset = NULL;
IColumnsRowset *pIColumnsRowset = NULL;
IUnknown *pIAggregate = NULL;
IRowsetInfo *pIRowsetInfo = NULL;
ULONG ulRefCountBefore;
ULONG ulRefCountAfter;
HRESULT hr = S_OK;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPSET *rgPropSet = NULL;
ULONG cPropSet = 0;
DBID *pTableID = NULL;
BOOL fCreatedTable = FALSE;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetSettableProperty(DBPROP_IColumnsRowset, DBPROPSET_ROWSET, &cPropSet, &rgPropSet);
TEST3C_(hr = CreateAndCheckTable(m_pITableDefinition, &Aggregate, NULL, cColumnDesc, rgColumnDesc,
IID_IUnknown, cPropSet, rgPropSet, &pTableID, (IUnknown**)&Aggregate.m_pIUnkInner),
S_OK, DB_E_ERRORSOCCURRED, DB_E_NOAGGREGATION);
if (DB_E_ERRORSOCCURRED == hr)
TESTC(!GetProperty(DBPROP_IColumnsRowset, DBPROPSET_ROWSET, pIRowset, VARIANT_TRUE));
TESTC_PROVIDER(S_OK == hr);
fCreatedTable = TRUE;
//Verify Aggregation
TESTC(Aggregate.VerifyAggregationQI(hr, IID_IRowset, (IUnknown**)&pIRowset));
//Obtain the ColumnsRowset interface [OPTIONAL] interface
TESTC_PROVIDER(VerifyInterface(pIRowset, IID_IColumnsRowset, ROWSET_INTERFACE, (IUnknown**)&pIColumnsRowset));
//IColumnsRowset::GetRowset
ulRefCountBefore = Aggregate.GetRefCount();
TESTC_(hr = pIColumnsRowset->GetColumnsRowset(NULL, 0, NULL, IID_IRowsetInfo, 0, NULL, (IUnknown**)&pIRowsetInfo),S_OK);
ulRefCountAfter = Aggregate.GetRefCount();
//GetSpecification
TEST2C_(hr = pIRowsetInfo->GetSpecification(IID_IAggregate, (IUnknown**)&pIAggregate),S_OK,S_FALSE);
if(hr==S_OK)
{
TESTC(VerifyEqualInterface(pIAggregate, pIRowset));
//Verify the child correctly addref'd the parent outer.
//The is an absolute requirement that the child keep the parent outer alive.
//If it doesn't addref the outer, the outer can be released externally since
//its not being used anymore due to the fact the outer controls the refcount
//of the inner. Many providers incorrectly addref the inner, which does nothing
//but guareentee the inner survives, but the inner will delegate to the outer
//and crash since it no longer exists...
TCOMPARE_(ulRefCountAfter > ulRefCountBefore);
}
else
{
TWARNING(L"IRowsetInfo::GetSpecification unable to retrieve Parent object!");
}
CLEANUP:
SAFE_RELEASE(pIRowsetInfo);
SAFE_RELEASE(pIAggregate);
SAFE_RELEASE(pIColumnsRowset);
SAFE_RELEASE(pIRowset);
Aggregate.ReleaseInner();
// checkings, etc
CHECK(DropTableAndCheck(pTableID), fCreatedTable? S_OK : E_INVALIDARG);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(76)
//*-----------------------------------------------------------------------
// @mfunc colid is ignored in a non column specific rowset property
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_76()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBPROPID dwPropID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hr;
DBPROPSTATUS dwStatus;
// make sure there is a non column specific rowset property that is settable
TESTC_PROVIDER(GetNonColSpecProp(DBPROPSET_ROWSET, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], dwPropID, DBTYPE_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
// get the result with DB_NULLID
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet);
dwStatus = rgProp[0].dwStatus;
if (S_OK != hr)
{
TESTC_(hr, DB_S_ERRORSOCCURRED);
TESTC(DBPROPSTATUS_NOTSUPPORTED == dwStatus);
}
else
{
TESTC(DBPROPSTATUS_OK == dwStatus);
}
// set colID to a value different from DB_NULLID
rgProp[0].colid.eKind = DBKIND_NAME;
rgProp[0].colid.uName.pwszName = L"someColumn";
// check colid is ignored for the rowset property
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet), hr);
TESTC(dwStatus == rgProp[0].dwStatus);
// check colid is ignored for the column property
rgProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
1, rgPropSet), S_OK == hr? S_OK: DB_E_ERRORSOCCURRED);
TESTC(dwStatus == rgProp[0].dwStatus);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(77)
//*-----------------------------------------------------------------------
// @mfunc colid is DB_NULLID in a column specific rowset property => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_77()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBPROPID dwPropID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hr;
// make sure there is a column specific rowset property that is settable
TESTC_PROVIDER(GetColSpecProp(DBPROPSET_ROWSET, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], dwPropID, DBTYPE_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
// explicitly set colID to DB_NULLID
rgProp[0].colid = DB_NULLID;
// check colid is ignored for the rowset property
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet);
if (DB_S_ERRORSOCCURRED == hr)
{
TESTC(DBPROPSTATUS_NOTALLSETTABLE == rgProp[0].dwStatus);
}
else
{
TESTC_(hr, S_OK);
TESTC(DBPROPSTATUS_OK == rgProp[0].dwStatus);
}
// check colid is ignored for the column property
rgProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
// check colid is ignored for the rowset property
hr = CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet);
if (DB_E_ERRORSOCCURRED == hr)
{
TESTC(DBPROPSTATUS_NOTALLSETTABLE == rgProp[0].dwStatus);
}
else
{
TESTC_(hr, S_OK);
TESTC(DBPROPSTATUS_OK == rgProp[0].dwStatus);
}
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(78)
//*-----------------------------------------------------------------------
// @mfunc valid, non DB_NULLID colid for a column specific rowset property
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_78()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBPROPID dwPropID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
memset(&rgProp[0].colid, 0, sizeof(DBID));
// make sure there is a column specific rowset property that is settable
TESTC_PROVIDER(GetColSpecProp(DBPROPSET_ROWSET, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], dwPropID, DBTYPE_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
// explicitly set colID to DB_NULLID
DuplicateDBID(m_rgColumnDesc[0].dbcid, &rgProp[0].colid);
// check colid is ignored for the rowset property
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet), S_OK);
COMPARE(DBPROPSTATUS_OK == rgProp[0].dwStatus, TRUE);
// check colid is ignored for the column property
rgProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
// check colid is ignored for the rowset property
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet), S_OK);
COMPARE(DBPROPSTATUS_OK == rgProp[0].dwStatus, TRUE);
CLEANUP:
ReleaseDBID(&rgProp[0].colid, FALSE);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(79)
//*-----------------------------------------------------------------------
// @mfunc invalid colid for a column specific rowset property
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_79()
{
TBEGIN
DBPROPSET rgPropSet[1];
DBPROP rgProp[1];
DBPROPID dwPropID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
// make sure there is a column specific rowset property that is settable
TESTC_PROVIDER(GetColSpecProp(DBPROPSET_ROWSET, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
rgColumnDesc[0].cPropertySets = 0;
rgColumnDesc[0].rgPropertySets = NULL;
FILL_PROP_SET(rgPropSet[0], 1, rgProp, DBPROPSET_ROWSET)
FILL_PROP(rgProp[0], dwPropID, DBTYPE_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_OPTIONAL)
// set colID to a value different from DB_NULLID
rgProp[0].colid.eKind = DBKIND_NAME;
rgProp[0].colid.uName.pwszName = L"someColumn";
// check colid is ignored for the rowset property
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet), DB_S_ERRORSOCCURRED);
COMPARE(DBPROPSTATUS_BADCOLUMN == rgProp[0].dwStatus, TRUE);
// check colid is ignored for the column property
rgProp[0].dwOptions = DBPROPOPTIONS_REQUIRED;
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 1, rgPropSet), DB_E_ERRORSOCCURRED);
COMPARE(DBPROPSTATUS_BADCOLUMN == rgProp[0].dwStatus, TRUE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(80)
//*-----------------------------------------------------------------------
// @mfunc Create a table. Retrieve a rowset on it (IRowsetInfo). Check GetSpecification()
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_80()
{
IRowsetInfo *pIRowsetInfo = NULL;
IOpenRowset *pIOpenRowset = NULL;
BOOL fTestRes = TEST_FAIL;
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hr;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_(CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc, IID_IRowsetInfo,
0, NULL, &pTableID, (IUnknown**)&pIRowsetInfo), S_OK);
hr = pIRowsetInfo->GetSpecification(IID_IOpenRowset, (IUnknown**)&pIOpenRowset);
if (S_FALSE != hr)
{
TESTC_(hr, S_OK);
TESTC(VerifyEqualInterface(m_pITableDefinition, pIOpenRowset));
}
fTestRes = TEST_PASS;
CLEANUP:
SAFE_RELEASE(pIRowsetInfo);
SAFE_RELEASE(pIOpenRowset);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
if (pTableID)
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
return fTestRes;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(81)
//*-----------------------------------------------------------------------
// @mfunc DB_NULLID is ignored for non column-related table properties
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_81()
{
TBEGIN
DBPROPSET rgPropSets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPID dwPropID;
// make sure there is a non column specific rowset property that is settable
TESTC_PROVIDER(GetNonColSpecProp(DBPROPSET_TABLE, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], dwPropID, VT_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
// setting a colid != DB_NULLID for a table property should result in error
rgProp[0].colid.eKind = DBKIND_NAME;
rgProp[0].colid.uName.pwszName = L"AliBaba";
CHECK(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), S_OK);
// TableID generated by provider
FILL_PROP(rgProp[0], dwPropID, VT_BOOL, V_BOOL,
VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), S_OK);
CLEANUP:
// checkings, etc
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(82)
//*-----------------------------------------------------------------------
// @mfunc Column related table property set to bad colid
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_82()
{
TBEGIN
DBPROPSET rgPropSets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBPROPID dwPropID;
// make sure there is a non column specific rowset property that is settable
TESTC_PROVIDER(GetColSpecProp(DBPROPSET_TABLE, &dwPropID));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], dwPropID, VT_BOOL, V_BOOL,
VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
// setting a colid != DB_NULLID for a table property should result in error
rgProp[0].colid.eKind = DBKIND_NAME;
rgProp[0].colid.uName.pwszName = L"AliBaba";
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), DB_S_ERRORSOCCURRED);
// TableID generated by provider
FILL_PROP(rgProp[0], dwPropID, VT_BOOL, V_BOOL,
VARIANT_FALSE, DBPROPOPTIONS_REQUIRED);
TESTC_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset,
NUMELEM(rgPropSets), rgPropSets), DB_E_ERRORSOCCURRED);
CLEANUP:
// checkings, etc
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(83)
//*-----------------------------------------------------------------------
// @mfunc How many DBTYPE_I4 columns?
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_83()
{
return TEST_PASS;
/*
TBEGIN
CTable *pCTable = new CTable(m_pThisTestModule->m_pIUnknown2,
(LPWSTR)gwszModuleName);
DBTYPE dbType = DBTYPE_I4;
BYTE precision = 0;
BYTE scale = 0;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
const ULONG MAX_VAL = 2048;
ULONG cColumnDesc = MAX_VAL / 2;
ULONG iCol;
ULONG offset = MAX_VAL / 4;
pCTable->SetBuildColumnDesc(FALSE);
for (;0 < offset;)
{
SAFE_ALLOC(rgColumnDesc, DBCOLUMNDESC, cColumnDesc);
memset(rgColumnDesc, 0, cColumnDesc*sizeof(DBCOLUMNDESC));
for (iCol = 0; iCol < cColumnDesc; iCol++)
{
// fill in a column
rgColumnDesc[iCol].wType = dbType;
rgColumnDesc[iCol].bPrecision = precision;
rgColumnDesc[iCol].bScale = scale;
rgColumnDesc[iCol].dbcid.eKind = DBKIND_NAME;
SAFE_ALLOC(rgColumnDesc[iCol].dbcid.uName.pwszName, WCHAR, 10);
swprintf(rgColumnDesc[iCol].dbcid.uName.pwszName, L"C%dCol", iCol);
}
pCTable->SetColumnDesc(rgColumnDesc, cColumnDesc);
hr = pCTable->CreateTable(100, 0);
if (SUCCEEDED(hr))
{
pCTable->DropTable();
if (cColumnDesc < MAX_VAL)
cColumnDesc += offset;
else
break;
}
else
{
if (cColumnDesc < offset)
break;
cColumnDesc -= offset;
}
offset /= 2;
}
odtLog << "Max no of columns : " << cColumnDesc << "\n";
CLEANUP:
pCTable->DropTable();
SAFE_DELETE(pCTable);
TRETURN
*/
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(84)
//*-----------------------------------------------------------------------
// @mfunc Open a rowset with CE, call IColumnRowset with an aggregated pIUnk
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_84()
{
TBEGIN
IRowsetFind *pIRowsetFind = NULL;
IColumnsRowset *pIColumnsRowset= NULL;
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
HRESULT hr;
CAggregate Aggregate(NULL);
TESTC_PROVIDER(SettableProperty(DBPROP_IRowsetFind, DBPROPSET_ROWSET));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TEST2C_(hr = CreateAndCheckTable(m_pITableDefinition, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowsetFind, 0, NULL, &pTableID, (IUnknown**)&pIRowsetFind), S_OK, E_NOINTERFACE);
TESTC_PROVIDER(S_OK == hr);
TESTC_(pIRowsetFind->QueryInterface(IID_IColumnsRowset, (LPVOID*)&pIColumnsRowset), S_OK);
TESTC_(hr = pIColumnsRowset->GetColumnsRowset(&Aggregate, 0, NULL, IID_IUnknown,
0, NULL, (IUnknown**)&Aggregate.m_pIUnkInner), S_OK);
// Verify Aggregation for this rowset...
TESTC(Aggregate.VerifyAggregationQI(hr, IID_IRowset));
CLEANUP:
Aggregate.ReleaseInner();
SAFE_RELEASE(pIRowsetFind);
SAFE_RELEASE(pIColumnsRowset);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
if (pTableID)
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(85)
//*-----------------------------------------------------------------------
// @mfunc Different DBKINDs for pTableID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_85()
{
TBEGIN
LPWSTR pwszColumnName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID TableID;
HRESULT hr;
// DBKIND_GUID_NAME
// DBKIND_GUID_PROPID
// DBKIND_NAME
// DBKIND_PGUID_NAME
// DBKIND_PGUID_PROPID
// DBKIND_PROPID
// DBKIND_GUID
m_pTable->MakeTableName(NULL);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
TEST2C_(hr = CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IUnknown,
0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_GUID_NAME;
TableID.uGuid.guid = guidModule;
m_pTable->MakeTableName(NULL);
TableID.uName.pwszName = m_pTable->GetTableName();
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_PGUID_NAME;
TableID.uGuid.pguid = &guidModule;
m_pTable->MakeTableName(NULL);
TableID.uName.pwszName = m_pTable->GetTableName();
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_GUID;
TableID.uGuid.guid = guidModule;
m_pTable->MakeTableName(NULL);
TableID.uName.pwszName = m_pTable->GetTableName();
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_GUID_PROPID;
TableID.uGuid.guid = guidModule;
TableID.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_PGUID_PROPID;
TableID.uGuid.pguid = &guidModule;
TableID.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
TableID.eKind = DBKIND_PROPID;
TableID.uGuid.pguid = &guidModule;
TableID.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(&TableID, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL, TRUE), S_OK, DB_E_BADTABLEID);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(86)
//*-----------------------------------------------------------------------
// @mfunc Different DBKINDs for column IDs
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTable::Variation_86()
{
TBEGIN
LPWSTR pwszColumnName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
// DBKIND_GUID_NAME
// DBKIND_GUID_PROPID
// DBKIND_NAME
// DBKIND_PGUID_NAME
// DBKIND_PGUID_PROPID
// DBKIND_PROPID
// DBKIND_GUID
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
pwszColumnName = rgColumnDesc[0].dbcid.uName.pwszName;
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_GUID_NAME;
rgColumnDesc[0].dbcid.uGuid.guid = guidModule;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_PGUID_NAME;
rgColumnDesc[0].dbcid.uGuid.pguid = &guidModule;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_GUID;
rgColumnDesc[0].dbcid.uGuid.guid = guidModule;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_GUID_PROPID;
rgColumnDesc[0].dbcid.uGuid.guid = guidModule;
rgColumnDesc[0].dbcid.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_PGUID_PROPID;
rgColumnDesc[0].dbcid.uGuid.pguid = &guidModule;
rgColumnDesc[0].dbcid.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_PROPID;
rgColumnDesc[0].dbcid.uGuid.pguid = &guidModule;
rgColumnDesc[0].dbcid.uName.ulPropid = 0xffL;
TEST2C_(CCNDropTable(NULL, cColumnDesc, rgColumnDesc, IID_IRowset, 0, NULL), S_OK, DB_E_BADCOLUMNID);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = pwszColumnName;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
CLEANUP:
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//--------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCreateTable::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }}
// }}
// {{ TCW_TC_PROTOTYPE(RODataSource)
//*-----------------------------------------------------------------------
//| Test Case: RODataSource - Test case for operating on a read only data source
//| Created: 10/13/97
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL RODataSource::Init()
{
BOOL fResults = TEST_SKIPPED;
IDBInitialize *pIDBInitialize = NULL;
IDBProperties *pIDBProperties = NULL;
DBPROPSET *rgPropSets = NULL;
ULONG cPropSets = 0;
HRESULT hr = NOERROR;
DBPROP *rgProperties = NULL;
const int n=1;
const ULONG nINIT_MODE = 0;
DBPROPIDSET rgPropIDSet[n];
DBPROPID rgPropID1[1];
ULONG nActualSize = n;
m_pIUnknown = NULL;
m_pIUnknown2 = NULL;
m_pITableDefinition2 = NULL;
m_pTable = NULL;
// {{ TCW_INIT_BASECLASS_CHECK
if(!TCDropColumn::Init())
// }}
goto CLEANUP2;
if (!SettableProperty(DBPROP_INIT_MODE, DBPROPSET_DBINIT))
{
odtLog << "DBPROP_INIT_MODE is not supported or is not a read-write property\n";
fResults = TEST_SKIPPED;
goto CLEANUP2;
}
// create a spare table on the read-write datasource
m_hr = m_pTable->CreateTable(10, 0);
m_pITableDefinition2 = m_pITableDefinition;
m_pITableDefinition = NULL;
fResults = FALSE;
if (!CHECK(m_hr, S_OK))
{
odtLog << "could not create atable on the read-write data source!\n";
goto CLEANUP;
}
// Setup the arrays needed for init, based on string LTM passed to us
if(!GetInitProps(&cPropSets, &rgPropSets))
goto CLEANUP;
// Get our initial connection to the provider, asking for IDBInitialize since
// we must initialize before anything else
if(!SUCCEEDED(m_hr = GetModInfo()->CreateProvider(NULL, IID_IDBInitialize, (IUnknown**)&pIDBInitialize)))
goto CLEANUP;
// Get IDBProperties Pointer
pIDBProperties = NULL;
if (!VerifyInterface(pIDBInitialize, IID_IDBProperties, DATASOURCE_INTERFACE, (IUnknown**)&pIDBProperties))
goto CLEANUP;
// Set the properties before we Initialize, only if we have Properties to set...
if (FAILED(m_hr = pIDBProperties->SetProperties(cPropSets, rgPropSets)))
goto CLEANUP;
// free the structures
FreeProperties(&cPropSets, &rgPropSets);
rgPropSets = NULL;
cPropSets = 0;
SetProperty(&rgPropSets, &cPropSets, DBPROP_INIT_MODE, VT_I4, (LPVOID)DB_MODE_READ, DBPROPOPTIONS_REQUIRED, DB_NULLID,
DBPROPSET_DBINIT);
// Set the properties before we Initialize, only if we have Properties to set...
if (FAILED(m_hr = pIDBProperties->SetProperties(cPropSets, rgPropSets)))
{
FindProperty(
DBPROP_INIT_MODE,
DBPROPSET_DBINIT,
cPropSets,
rgPropSets,
&rgProperties);
if (DBPROPSTATUS_OK != rgProperties->dwStatus)
odtLog << "Read only property could not be initialized!\n";
goto CLEANUP1;
}
else
{
PRVTRACE("RODataSource::Init(): Apparently the read only property was set\n");
FindProperty(
DBPROP_INIT_MODE,
DBPROPSET_DBINIT,
cPropSets,
rgPropSets,
&rgProperties);
if (DBPROPSTATUS_OK != rgProperties->dwStatus)
odtLog << "ERROR: Read only property could not be initialized in fact!\n";
}
FreeProperties( &cPropSets, &rgPropSets);
// Initialize
if(!GCHECK(m_hr = pIDBInitialize->Initialize(), S_OK))
{
odtLog << wszInitializeFailed;
goto CLEANUP1;
}
// check that the read only property was set
rgPropID1[0] = DBPROP_INIT_MODE;
rgPropIDSet[nINIT_MODE].cPropertyIDs = 1;
rgPropIDSet[nINIT_MODE].rgPropertyIDs = rgPropID1;
rgPropIDSet[nINIT_MODE].guidPropertySet = DBPROPSET_DBINIT;
CHECK(m_hr = pIDBProperties->GetProperties(nActualSize, rgPropIDSet, &cPropSets, &rgPropSets), S_OK);
if ( (DBPROPSTATUS_OK == rgPropSets[nINIT_MODE].rgProperties[0].dwStatus)
&& ( (VT_I4 != rgPropSets[nINIT_MODE].rgProperties[0].vValue.vt)
|| (DB_MODE_READ != V_I4(&rgPropSets[nINIT_MODE].rgProperties[0].vValue))))
{
odtLog << "despite ok reports, DBPROP_INIT_MODE is not set to read only\n";
goto CLEANUP1;
}
// Obtain IDBCreateSesson, placing the new DSO interface
// in CThisTestModule's m_pIUnknown, so that all testcases can use
// it via their back pointer to this object. No need to call AddRef
// here as we will own it, rather than the test module.
if (!VerifyInterface(pIDBInitialize, IID_IDBCreateSession, DATASOURCE_INTERFACE,
(IUnknown**)&m_pIUnknown))
goto CLEANUP1;
// Create a DB session object
// Set the m_pIUnknown2 to IOpenRowset
if (!GCHECK(((IDBCreateSession*)m_pIUnknown)->CreateSession(
NULL, IID_IOpenRowset, (IUnknown **)&m_pIUnknown2), S_OK))
goto CLEANUP1;
SetDBSession(m_pIUnknown2); // calls ReleaseDBSession Before
// switch the interface on ItableDefinition
if (!(m_hr=VerifyInterface(m_pIUnknown2, IID_ITableDefinition, SESSION_INTERFACE,
(IUnknown**)&m_pITableDefinition)))
goto CLEANUP1;
fResults = TRUE;
CLEANUP1:
FreeProperties( &cPropSets, &rgPropSets);
CLEANUP:
SAFE_RELEASE(pIDBProperties);
SAFE_RELEASE(pIDBInitialize);
return fResults;
CLEANUP2:
if (m_pITableDefinition)
{
m_pITableDefinition2 = m_pITableDefinition;
m_pITableDefinition = NULL;
}
return fResults;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Add a column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RODataSource::Variation_1()
{
BOOL fResults = TEST_PASS;
DBID *pColumnID = NULL;
HRESULT hr;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = m_pTable->CountColumnsOnTable();
m_pTable->BuildColumnDescs(&rgColumnDesc);
TESTC(0 < cColumnDesc);
PROVIDER_FREE(rgColumnDesc->dbcid.uName.pwszName);
FreeProperties( &rgColumnDesc->cPropertySets, &rgColumnDesc->rgPropertySets);
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"newColumn");
if (!CHECK(hr = m_pITableDefinition->AddColumn(&m_pTable->GetTableID(), rgColumnDesc, &pColumnID),
DB_SEC_E_PERMISSIONDENIED))
fResults = TEST_FAIL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
CLEANUP:
return fResults;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Drop a column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RODataSource::Variation_2()
{
TBEGIN;
DBID ColumnID;
DBCOLUMNDESC *oldCD = NULL;
DBORDINAL oldlen = 0;
GetColumnDescOnTable(&m_pTable->GetTableID(), &oldCD, &oldlen);
TESTC_PROVIDER(1 < oldlen);
ColumnID.eKind = DBKIND_NAME;
ColumnID.uName.pwszName = oldCD[0].dbcid.uName.pwszName;
TEST2C_(DropColumnAndCheck(&m_pTable->GetTableID(), &ColumnID), S_OK, DB_SEC_E_PERMISSIONDENIED);
CLEANUP:
ReleaseColumnDesc(oldCD, oldlen);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Create a table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RODataSource::Variation_3()
{
BOOL fResults = TEST_PASS;
DBID *pTableID = NULL;
if (!CHECK(m_pITableDefinition->CreateTable(NULL, NULL, m_cColumnDesc, m_rgColumnDesc,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_SEC_E_PERMISSIONDENIED))
{
fResults = TEST_FAIL;
m_pITableDefinition->DropTable(pTableID);
}
ReleaseDBID(pTableID);
return fResults;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Drop a table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int RODataSource::Variation_4()
{
BOOL fResults = TEST_PASS;
BOOL fExists;
if ( !CHECK(m_pITableDefinition->DropTable(&m_pTable->GetTableID()), DB_SEC_E_PERMISSIONDENIED)
|| !CHECK(m_pTable->DoesTableExist(&m_pTable->GetTableID(), &fExists), S_OK)
|| !fExists)
fResults = TEST_FAIL;
return fResults;
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL RODataSource::Terminate()
{
// {{ TCW_TERM_BASECLASS_CHECK2
SAFE_RELEASE(m_pITableDefinition);
m_pITableDefinition = m_pITableDefinition2;
m_pITableDefinition2 = NULL;
SetDBSession(m_pITableDefinition);
if (m_pTable)
{
m_hr = m_pTable->DropTable();
delete m_pTable;
m_pTable = NULL;
}
return(TCDropColumn::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// Hack to defile CoInitializeEx
WINOLEAPI CoInitializeEx(LPVOID pvReserved, DWORD dwCoInit);
unsigned WINAPI ThreadProc(LPVOID lpvThreadParam)
{
CoInitializeEx(NULL, 0);
TCITableDefinition *pObject = ((CInParam*)lpvThreadParam)->pObject;
pObject->MyThreadProc(((CInParam*)lpvThreadParam)->i);
CoUninitialize();
return 1;
} //ThreadProc
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_Boundary)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_Boundary - General and boundary/null test for ITableDefinitionWithConstraints::AddConstraint
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_Boundary::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL || GetModInfo()->GetClassContext()==CLSCTX_LOCAL_SERVER)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Check the session object (QI for interfaces)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_1()
{
return DefaultObjectTesting(m_pThisTestModule->m_pIUnknown2, SESSION_INTERFACE);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_2()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
CHECK(AddConstraintAndCheck(m_pITDWC, NULL, consFK), E_INVALIDARG);
CHECK(AddConstraintAndCheck(m_pITDWC, NULL, consPK), E_INVALIDARG);
CHECK(AddConstraintAndCheck(m_pITDWC, NULL, consUnique), E_INVALIDARG);
CHECK(AddConstraintAndCheck(m_pITDWC, NULL, consCheck), E_INVALIDARG);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc *pTableID is DB_NULLID => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_3()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
DuplicateDBID(DB_NULLID, &TableID);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Table name is NULL => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_4()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Table name is the empty string => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_5()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 17), S_OK);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = wcsDuplicate(L"");
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Table name has maximum length
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_6()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
// create a table with maximum length
BaseTable.MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName, BaseTable.GetTableName());
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0, TableID.uName.pwszName), S_OK);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), S_OK);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Table name exceeds maximum length => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_7()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
// create a table with maximum length
BaseTable.MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildValidName(m_cMaxTableName+1, BaseTable.GetTableName());
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Table name contains illegal characters
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_8()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
size_t m, n;
// create a table with maximum length
BaseTable.MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
m = min(m_cMaxTableName, n=5+wcslen(BaseTable.GetTableName()));
TableID.uName.pwszName = BuildInvalidName(m, BaseTable.GetTableName(), m_pwszInvalidTableChars);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Invalid DBKIND value for the base table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_9()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID TableID;
// create a table with maximum length
BaseTable.MakeTableName(NULL);
memset(&TableID, 0, sizeof(DBID));
TableID.eKind = 0xce;
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgBaseCol[0], 12), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consFK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consPK), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consUnique), DB_E_NOTABLE);
TESTC_(AddConstraintAndCheck(m_pITDWC, &TableID, consCheck), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc NULL column list in a constraint, column size is not 0 => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_10()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1, 2, 3};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCONSTRAINTDESC *pConsDesc;
DBID *p1 = NULL, *p2 = NULL;
// create a table with maximum length
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consUnique;
p1 = pConsDesc->rgColumnList;
pConsDesc->rgColumnList = NULL;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), E_INVALIDARG);
pConsDesc->rgColumnList = p1;
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consPK;
p1 = pConsDesc->rgColumnList;
pConsDesc->rgColumnList = NULL;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), E_INVALIDARG);
pConsDesc->rgColumnList = p1;
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
p1 = pConsDesc->rgColumnList;
pConsDesc->rgColumnList = NULL;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG);
p2 = pConsDesc->rgForeignKeyColumnList;
pConsDesc->rgForeignKeyColumnList = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG);
pConsDesc->rgColumnList = p1;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG);
pConsDesc->rgColumnList = p1;
pConsDesc->rgForeignKeyColumnList = p2;
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc NULL column name in a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_11()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1, 2, 3};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCONSTRAINTDESC *pConsDesc;
// create a table with maximum length
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = NULL;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[2], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgForeignKeyColumnList[1].uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[1], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgForeignKeyColumnList[1].uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consUnique;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consPK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Empty string for a column name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_12()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1, 2, 3};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCONSTRAINTDESC *pConsDesc;
// create a table with maximum length
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = wcsDuplicate(L"");
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = wcsDuplicate(L"");
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[2], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgForeignKeyColumnList[1].uName.pwszName = wcsDuplicate(L"");
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[1], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgForeignKeyColumnList[1].uName.pwszName = wcsDuplicate(L"");
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consUnique;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = wcsDuplicate(L"");
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consPK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = DBKIND_NAME;
pConsDesc->rgColumnList[1].uName.pwszName = wcsDuplicate(L"");
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Maximum length column name in a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_13()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
WCHAR *pwszName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
BaseTable.SetColumnDesc(rgColumnDesc, cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
BaseTable.MakeTableName(NULL);
pwszName = wcsDuplicate(BaseTable.GetTableName());
if (rgColumnDesc[0].dbcid.uName.pwszName)
SAFE_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszName);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgCol), rgCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, rgCol[0], 12), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), S_OK);
CLEANUP:
SAFE_FREE(pwszName);
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Column name exceeds maximum length
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_14()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
WCHAR *pwszName = NULL;
WCHAR *pwszColName = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBCONSTRAINTDESC *pConsDesc;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
BaseTable.SetColumnDesc(rgColumnDesc, cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
BaseTable.MakeTableName(NULL);
pwszName = wcsDuplicate(BaseTable.GetTableName());
if (rgColumnDesc[0].dbcid.uName.pwszName)
SAFE_FREE(rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszName);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgCol), rgCol), S_OK);
pwszColName = BuildValidName(m_cMaxColName+1, pwszName);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
SAFE_FREE(pConsDesc->rgForeignKeyColumnList[0].uName.pwszName);
pConsDesc->rgForeignKeyColumnList[0].uName.pwszName = wcsDuplicate(pwszColName);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
pConsDesc = consUnique;
SAFE_FREE(pConsDesc->rgColumnList[0].uName.pwszName);
pConsDesc->rgColumnList[0].uName.pwszName = wcsDuplicate(pwszColName);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
pConsDesc = consPK;
SAFE_FREE(pConsDesc->rgColumnList[0].uName.pwszName);
pConsDesc->rgColumnList[0].uName.pwszName = wcsDuplicate(pwszColName);
// set up the check constraint
CHECK(consCheck.SetIsNotNULLCheckConstraint(pwszColName), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), E_FAIL);
CLEANUP:
SAFE_FREE(pwszColName);
SAFE_FREE(pwszName);
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Invalid DBKIND for a column DBID of a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_15()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1, 2, 3};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCONSTRAINTDESC *pConsDesc;
// create a table with maximum length
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = 0xfe;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = 0xfe;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[2], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = 0xfe;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[1], FALSE);
pConsDesc->rgForeignKeyColumnList[1].eKind = 0xfe;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consUnique;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = 0xee;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consPK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
pConsDesc->rgColumnList[1].eKind = 0xac;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Column ID is DB_NULLID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_16()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1, 2, 3};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCONSTRAINTDESC *pConsDesc;
// create a table with maximum length
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
DuplicateDBID(DB_NULLID, &pConsDesc->rgColumnList[1]);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
DuplicateDBID(DB_NULLID, &pConsDesc->rgColumnList[1]);
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[2], FALSE);
DuplicateDBID(DB_NULLID, &pConsDesc->rgForeignKeyColumnList[1]);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
pConsDesc = consFK;
ReleaseDBID(&pConsDesc->rgForeignKeyColumnList[1], FALSE);
DuplicateDBID(DB_NULLID, &pConsDesc->rgForeignKeyColumnList[1]);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consUnique;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
memset(&pConsDesc->rgColumnList[1], 0, sizeof(DBID));
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pConsDesc = consPK;
ReleaseDBID(&pConsDesc->rgColumnList[1], FALSE);
memset(&pConsDesc->rgColumnList[1], 0, sizeof(DBID));
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_17()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
// create the referenced table in this catalog
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
consFK.SetReferencedTableID(NULL);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_BADCONSTRAINTFORM);
CHECK(consFK.ReleaseForeignKeyColumnList(), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_BADCONSTRAINTFORM);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc DBNULL_ID *pReferencedTableID for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_18()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
// create the referenced table in this catalog
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the constraint
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
consFK.SetReferencedTableID((DBID*)&DB_NULLID);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc NULL referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_19()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
DBID ReferencedTableID;
// create the referenced table in this catalog
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = NULL;
consFK.SetReferencedTableID(&ReferencedTableID);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Emptry string referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_20()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
DBID ReferencedTableID;
// create the referenced table in this catalog
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the constraint
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = L"";
consFK.SetReferencedTableID(&ReferencedTableID);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Maximum length referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_21()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
WCHAR *pwszTableName = NULL;
// create the referenced table in this catalog
// create a table with maximum length
ReferencedTable.MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, ReferencedTable.GetTableName());
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0, pwszTableName));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), S_OK);
CLEANUP:
SAFE_FREE(pwszTableName);
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Referenced table name longer than allowed for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_22()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
WCHAR *pwszTableName = NULL;
DBCONSTRAINTDESC *pConsDesc = consFK;
// create the referenced table in this catalog
// create a table with maximum length
ReferencedTable.MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, ReferencedTable.GetTableName());
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0, pwszTableName));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
SAFE_FREE(pwszTableName);
ReleaseDBID(pConsDesc->pReferencedTableID, FALSE);
pConsDesc->pReferencedTableID->eKind = DBKIND_NAME;
pConsDesc->pReferencedTableID->uName.pwszName = BuildValidName(m_cMaxTableName + 1, ReferencedTable.GetTableName());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOTABLE);
CLEANUP:
SAFE_FREE(pwszTableName);
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Illegal characters in the referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_23()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
DBID ReferencedTableID;
size_t m, n;
// create the referenced table in this catalog
// create a table with maximum length
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the constraint
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
m = min(m_cMaxTableName, n=5+wcslen(ReferencedTable.GetTableName()));
ReferencedTableID.uName.pwszName = BuildInvalidName(m, ReferencedTable.GetTableName(), m_pwszInvalidTableChars);
consFK.SetReferencedTableID(&ReferencedTableID);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
ReleaseDBID(&ReferencedTableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Bad constraint type
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_24()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CConsDesc cons((DBCONSTRAINTTYPE)0xfd);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_BADCONSTRAINTTYPE);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Empty list of columns for a unique, primay key or foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_25()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
WCHAR *pwszConstraintText = NULL;
WCHAR *pwszColValue = NULL;
CCol col;
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
consFK.ReleaseColumnList();
TEST2C_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG, DB_E_BADCONSTRAINTFORM);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
consFK.ReleaseForeignKeyColumnList();
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_BADCONSTRAINTFORM);
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
consFK.ReleaseForeignKeyColumnList();
consFK.ReleaseColumnList();
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_BADCONSTRAINTFORM);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
consUnique.ReleaseColumnList();
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_BADCONSTRAINTFORM);
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
consPK.ReleaseColumnList();
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_BADCONSTRAINTFORM);
CLEANUP:
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Non empty list of columns for a check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_26()
{
TBEGIN
HRESULT hr;
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CCheckCons consCheck;
DBCONSTRAINTDESC *pcons = consCheck;
WCHAR *pwszConstraintText = NULL;
WCHAR *pwszColValue = NULL;
CCol col;
DBID rgColList;
DBID rgForeignKeyColList;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// set up the check constraint
CHECK(consCheck.SetLTCheckConstraint(&BaseTable, 1, 12), S_OK);
DuplicateDBID(*col.GetColID(), &rgColList);
DuplicateDBID(*col.GetColID(), &rgForeignKeyColList);
// not empty rgColumnList
pcons->cColumns = 1;
pcons->rgColumnList = &rgColList;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), DB_E_BADCONSTRAINTFORM);
// not empty rgForeignKeyColumnList
pcons->cColumns = 0;
pcons->rgColumnList = NULL;
pcons->cForeignKeyColumns = 1;
pcons->rgForeignKeyColumnList = &rgForeignKeyColList;
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck);
// since the number of columns is different from the number of foreign key columns
// E_INVALIDARG can be returned as well
if (E_INVALIDARG != hr)
CHECK(hr, DB_E_BADCONSTRAINTFORM);
// not empty rgColumnList and rgForeignKeyColumnList
pcons->cColumns = 1;
pcons->rgColumnList = &rgColList;
pcons->cForeignKeyColumns = 1;
pcons->rgForeignKeyColumnList = &rgForeignKeyColList;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), DB_E_BADCONSTRAINTFORM);
CLEANUP:
pcons->cColumns = 0;
pcons->rgColumnList = NULL;
pcons->cForeignKeyColumns = 0;
pcons->rgForeignKeyColumnList = NULL;
ReleaseDBID(&rgColList, FALSE);
ReleaseDBID(&rgForeignKeyColList, FALSE);
SAFE_FREE(pwszConstraintText);
SAFE_FREE(pwszColValue);
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Not null pwszConstraintText in a unique, PK or FK constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_27()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
DBCONSTRAINTDESC *pcons;
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
pcons = consFK;
pcons->pwszConstraintText = L"fdfd";
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pcons = consUnique;
pcons->pwszConstraintText = L"fdfd";
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
pcons = consPK;
pcons->pwszConstraintText = L"fdfd";
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_BADCONSTRAINTFORM);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_BADCONSTRAINTFORM);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_BADCONSTRAINTFORM);
CLEANUP:
pcons = consFK;
pcons->pwszConstraintText = NULL;
pcons = consPK;
pcons->pwszConstraintText = NULL;
pcons = consUnique;
pcons->pwszConstraintText = NULL;
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc NULL pConstraintDesc => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_28()
{
TBEGIN
CHECK(AddConstraintAndCheck(m_pITDWC, &m_pTable->GetTableID(), NULL), E_INVALIDARG);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc 0 < cColumns and NULL == rgColumnList => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_29()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
CHECK(consFK.ReleaseColumnList(), S_OK);
((DBCONSTRAINTDESC*)consFK)->cColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG);
((DBCONSTRAINTDESC*)consFK)->cColumns = 0;
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
CHECK(consUnique.ReleaseColumnList(), S_OK);
((DBCONSTRAINTDESC*)consUnique)->cColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), E_INVALIDARG);
((DBCONSTRAINTDESC*)consUnique)->cColumns = 0;
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
CHECK(consPK.ReleaseColumnList(), S_OK);
((DBCONSTRAINTDESC*)consPK)->cColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), E_INVALIDARG);
((DBCONSTRAINTDESC*)consPK)->cColumns = 0;
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
((DBCONSTRAINTDESC*)consCheck)->cColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), E_INVALIDARG);
((DBCONSTRAINTDESC*)consCheck)->cColumns = 0;
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc 0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_30()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgBaseCol), rgBaseCol, m_SupportedMatchType), S_OK);
CHECK(consFK.ReleaseForeignKeyColumnList(), S_OK);
((DBCONSTRAINTDESC*)consFK)->cForeignKeyColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), E_INVALIDARG);
((DBCONSTRAINTDESC*)consFK)->cForeignKeyColumns = 0;
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), E_INVALIDARG);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = 0;
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), E_INVALIDARG);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = 0;
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = 3;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), E_INVALIDARG);
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = 0;
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc Constraint is not foreign key and pReferencedTableID is not NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_31()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBID ReferencedTableID;
WCHAR *pwszConstraintText = NULL;
WCHAR *pwszColValue = NULL;
CCol col;
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = (LPWSTR)0x01234567;
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consUnique)->pReferencedTableID = &ReferencedTableID;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consUnique)->pReferencedTableID = NULL;
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consPK)->pReferencedTableID = &ReferencedTableID;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consPK)->pReferencedTableID = NULL;
// set up the check constraint
TESTC_(BaseTable.GetColInfo(rgBaseCol[0], col), S_OK);
TESTC_(BaseTable.GetLiteralAndValue(col, &pwszColValue, rand(), col.GetColNum(), PRIMARY), S_OK);
SAFE_FREE(pwszConstraintText);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(pwszColValue) + 3);
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, L" < ");
wcscat(pwszConstraintText, pwszColValue);
consCheck.SetConstraintText(pwszConstraintText);
((DBCONSTRAINTDESC*)consCheck)->pReferencedTableID = &ReferencedTableID;
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consCheck)->pReferencedTableID = NULL;
CLEANUP:
SAFE_FREE(pwszConstraintText);
SAFE_FREE(pwszColValue);
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc Non empty list of foreign keys for a constraint that is not foreign key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_32()
{
TBEGIN
HRESULT hr;
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
const DBORDINAL cColumns = 2;
DBID rgColumnList[cColumns];
DBORDINAL rgBaseCol[cColumns] = {1, 2};
rgColumnList[0].eKind = DBKIND_NAME;
rgColumnList[0].uName.pwszName = (LPWSTR)0x01234567;
rgColumnList[1].eKind = 0xfe;
rgColumnList[1].uName.pwszName = (LPWSTR)0x01234567;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// set up the unique constraint
TESTC_(consUnique.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consUnique)->rgForeignKeyColumnList = rgColumnList;
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique);
CHECK(hr, DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consUnique)->rgForeignKeyColumnList = NULL;
// set up the primary key constraint
TESTC_(consPK.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol), S_OK);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consPK)->rgForeignKeyColumnList = rgColumnList;
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK);
CHECK(hr, DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consPK)->rgForeignKeyColumnList = NULL;
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consCheck)->rgForeignKeyColumnList = rgColumnList;
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck);
if (E_INVALIDARG != hr)
CHECK(hr, DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consCheck)->rgForeignKeyColumnList = NULL;
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Inexistent referenced table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_33()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons cons;
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
// create a table
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// select a column
TESTC_(cons.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// set referenced table to an inexistent table name
Table.MakeTableName(NULL);
cons.SetReferencedTableID(&Table.GetTableID());
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Add several constraints to the table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_34()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
CCheckCons consCheck;
DBORDINAL rgReferencedCol[] = {1};
DBORDINAL rgCols[] = {1};
CCol col;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
ReferencedTable.GetTableID().eKind? ReferencedTable.GetTableID().uName.pwszName: NULL);
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
BaseTable.GetTableID().eKind? BaseTable.GetTableID().uName.pwszName: NULL);
// set a unique constraint on the second column
CHECK(consUnique.SetConstraint(&BaseTable, 1, rgCols), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), S_OK);
// set a primary key on the first column of the table
CHECK(consPrimaryKey.SetConstraint(&BaseTable, 1, rgCols), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPrimaryKey), S_OK);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
TESTC_(BaseTable.GetColInfo(1, col), S_OK);
consForeignKey.AddForeignKeyColumn(col.GetColID());
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consForeignKey), S_OK);
TESTC_(consCheck.SetLTCheckConstraint(&BaseTable, 2, 3), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), S_OK);
CLEANUP:
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Inexistent table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_35()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
CForeignKeyCons consFK(NULL, m_SupportedMatchType);
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
CCol col;
DBID dbidInexistent;
dbidInexistent.eKind = DBKIND_NAME;
dbidInexistent.uName.pwszName = L"Inexistent";
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgCol), rgCol), S_OK);
TESTC_(ReferencedTable.GetColInfo(rgCol[0], col), S_OK);
// since base table name has to be inexistent, use reference table name instead
consFK.SetReferencedTableID(&ReferencedTable.GetTableID());
consFK.AddColumn(col.GetColID());
consFK.AddForeignKeyColumn(col.GetColID());
// set up the unique constraint
consUnique.AddColumn(col.GetColID());
// set up the primary key constraint
consPK.AddColumn(col.GetColID());
// set up the check constraint
CHECK(consCheck.SetIsNotNULLCheckConstraint(col.GetColID()->uName.pwszName), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &dbidInexistent, consFK), DB_E_NOTABLE);
CHECK(AddConstraintAndCheck(m_pITDWC, &dbidInexistent, consPK), DB_E_NOTABLE);
CHECK(AddConstraintAndCheck(m_pITDWC, &dbidInexistent, consUnique), DB_E_NOTABLE);
CHECK(AddConstraintAndCheck(m_pITDWC, &dbidInexistent, consCheck), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc Inexistent column name => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Boundary::Variation_36()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID dbidInexistent;
dbidInexistent.eKind = DBKIND_NAME;
dbidInexistent.uName.pwszName = L"Inexistent";
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
BaseTable.SetColumnDesc(rgColumnDesc, cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgCol), rgCol), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(consFK.SetConstraint(&BaseTable, 0, NULL,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
consFK.AddForeignKeyColumn(&dbidInexistent);
// set up the unique constraint
consUnique.AddColumn(&dbidInexistent);
// set up the primary key constraint
consPK.AddColumn(&dbidInexistent);
// set up the check constraint
CHECK(consCheck.SetIsNotNULLCheckConstraint(dbidInexistent.uName.pwszName), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consFK), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consPK), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consUnique), DB_E_NOCOLUMN);
CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), consCheck), DB_E_NOCOLUMN);
CLEANUP:
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_Boundary::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_UNIQUE)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_UNIQUE - Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_UNIQUE::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Create a table and try to apply the constraint on each column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_1()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL index;
CUniqueCons cons;
DBORDINAL cColCount = 0,
cTotalLength = 0,
start = 1,
cColsInTable = 0;
HRESULT hrExpected;
ULONG ulNumberOfTests = 0;
// create the base table
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// build the constraint
// try to set all the columns in the unique keyunique
// Step 1: Skip BLOBs and Variable length columns
// and set Unique constraint on fixed length columns.
// It should succeed.
cColsInTable = Table.CountColumnsOnTable();
while(start < cColsInTable) {
cons.ReleaseColumnList();
cTotalLength = 0;
hrExpected = S_OK;
for (index = start, cColCount = 0; index <= Table.CountColumnsOnTable() &&
cColCount < cMaxColsPerCons; index++)
{
CCol col;
DBORDINAL colSizeInBytes = 0; //how many bytes the column contributes into maximum size of constraint
TESTC_(Table.GetColInfo(index, col), S_OK);
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if(col.GetIsFixedLength() )
colSizeInBytes = col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1);
else
colSizeInBytes = 0;
if (col.GetIsLong() ||
cTotalLength + colSizeInBytes > cMaxColLengthPerCons)
continue;
cTotalLength += colSizeInBytes;
cons.AddColumn(col.GetColID());
cColCount++;
}
if (cColCount)
{
ulNumberOfTests++;
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), hrExpected);
if (hrExpected == S_OK) {
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
}
}
start = index;
}
TESTC(ulNumberOfTests>0);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Set a unique constraint on each type of column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_2()
{
TBEGIN
DBORDINAL index;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
HRESULT hrExpected = S_OK;
// create a new table with a NOT NULLABLE column
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
Table.BuildColumnDescs(&rgNewColumnDesc);
for (index=1; index <= Table.CountColumnsOnTable(); index++)
{
CCol col;
TESTC_(Table.GetColInfo(index, col), S_OK);
cons.ReleaseColumnList();
cons.AddColumn(col.GetColID());
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if (col.GetIsLong() ||
(col.GetIsFixedLength() && (col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1) > cMaxColLengthPerCons)))
hrExpected = E_FAIL;
else
hrExpected = S_OK;
odtLog << col.GetProviderTypeName() << "\t -> Expected: " << (hrExpected==S_OK ? "S_OK" : "E_FAIL") << "\n";
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), hrExpected);
if (hrExpected == S_OK) {
CHECK(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
}
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), hrExpected);
if (hrExpected == S_OK) {
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Create a unique constraint that uses several columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_3()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL index;
DBORDINAL indxCol;
CUniqueCons cons;
DBORDINAL cCols;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
DBORDINAL cTotalLength = 0;
// create a new table with a NOT NULLABLE column
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
Table.BuildColumnDescs(&rgNewColumnDesc);
cCols = 2 + rand() % __min(20, (Table.CountColumnsOnTable()-1));
for (index=0, indxCol=1; index < cCols && indxCol <= Table.CountColumnsOnTable(); indxCol++)
{
CCol col;
DBORDINAL colSizeInBytes = 0; //how many bytes the column contributes into maximum size of constraint
//make sure we have at least 2 columns before randomizing the rest
if ( cons.cColumns() < 2 || rand() % 2)
{
TESTC_(Table.GetColInfo(indxCol, col), S_OK);
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if(col.GetIsFixedLength() )
colSizeInBytes = col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1);
else
colSizeInBytes = 0;
if (col.GetIsLong() ||
cTotalLength + colSizeInBytes > cMaxColLengthPerCons)
continue;
// put this column in the list
cTotalLength += colSizeInBytes;
cons.AddColumn(col.GetColID());
index++;
}
}
odtLog << "Constraint has " << cons.cColumns() << " columns\n";
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(cons.MakeConstraintName(), S_OK);
// try the same when creating a table
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Create several unique constraints on a table, no overlapping
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_4()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CUniqueCons cons2;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TESTC_PROVIDER(4 <= Table.CountColumnsOnTable());
// choose 2 columns and create a unique constraint on them
TESTC_(Table.GetColInfo(4, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(Table.GetColInfo(2, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// choose another 2 columns and create a unique constraint
TESTC_(Table.GetColInfo(3, col), S_OK);
cons2.AddColumn(col.GetColID());
TESTC_(Table.GetColInfo(1, col), S_OK);
cons2.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons2), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Create multiple, overlapping constraints on a table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_5()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CUniqueCons cons2;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TESTC_PROVIDER(3 <= Table.CountColumnsOnTable());
// choose 2 columns and create a unique constraint on them
TESTC_(Table.GetColInfo(3, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(Table.GetColInfo(2, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// choose another 2 columns and create a unique constraint
TESTC_(Table.GetColInfo(1, col), S_OK);
cons2.AddColumn(col.GetColID());
TESTC_(Table.GetColInfo(3, col), S_OK);
cons2.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons2), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint, drop it and recreate it
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_6()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint and recreate it
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint on a null column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_7()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// by setting DBCOLUMNDESC, all nullable type column are created as nullable
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// identify a nullable column
TESTC_PROVIDER(S_OK == Table.GetColInfo(IsCColNullable, col));
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Create a contraint on a not nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_8()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// identify a nullable column
TESTC_PROVIDER(S_OK == Table.GetColInfo(IsCColNotNullable, col));
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint on a column that has a default value
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_9()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
VARIANT value;
DBORDINAL indexCol;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
DBID *pTableID = NULL;
Table.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// by setting DBCOLUMNDESC, all nullable type column are created as nullable
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
// create a default value on one of the columns
VariantInit(&value);
indexCol = 2;
if (rgNewColumnDesc[indexCol-1].pwszTypeName)
odtLog << "Default value on type " << rgNewColumnDesc[indexCol-1].pwszTypeName << "\n";
GetDefaultValue(&rgNewColumnDesc[indexCol-1], &value, &Table);
SetDefaultProperty(&rgNewColumnDesc[indexCol-1].rgPropertySets, &rgNewColumnDesc[indexCol-1].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&value);
Table.SetBuildColumnDesc(FALSE);
TESTC_PROVIDER(S_OK == Table.CreateTable(0, 0));
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// identify a nullable column
TESTC_(Table.GetColInfo(indexCol, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint on a column defined as a primary key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_10()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBORDINAL indexCol;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
DBID *pTableID = NULL;
Table.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// by setting DBCOLUMNDESC, all nullable type column are created as nullable
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
// create a default value on one of the columns
indexCol = 3;
if (rgNewColumnDesc[indexCol-1].pwszTypeName)
odtLog << "Default value on type " << rgNewColumnDesc[indexCol-1].pwszTypeName << "\n";
SetProperty(&rgNewColumnDesc[indexCol-1].rgPropertySets, &rgNewColumnDesc[indexCol-1].cPropertySets,
DBPROP_COL_PRIMARYKEY,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
Table.SetBuildColumnDesc(FALSE);
TESTC_PROVIDER(S_OK == Table.CreateTable(0, 0));
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// identify a nullable column
TESTC_(Table.GetColInfo(indexCol, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// try the same when creating a table
cons.MakeConstraintName();
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint on a column defined as a foreign key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_11()
{
TBEGIN
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col, col2;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBORDINAL indexCol;
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CForeignKeyCons cons2(NULL, m_SupportedMatchType);
DBCONSTRAINTDESC *pConsDesc2 = (DBCONSTRAINTDESC*)cons2;
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// select a column
TESTC(RefTable.CountColumnsOnTable() == BaseTable.CountColumnsOnTable())
indexCol = 1;
TESTC_(RefTable.GetColInfo(indexCol, col2), S_OK);
TESTC_(BaseTable.GetColInfo(indexCol, col), S_OK);
TESTC_(AddUniqueConstraint(&RefTable, 1, &indexCol), S_OK);
// build the foreign key constraint, use corresponding columns in tables
// set column on base table
cons2.AddColumn(col2.GetColID());
// set foreign column
cons2.AddForeignKeyColumn(col.GetColID());
// set reference table
cons2.SetReferencedTableID(&RefTable.GetTableID());
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons2), S_OK);
// prepare and add the unique constraint on the column involved in a foreign key
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Create a constraint on a column that is included in an index
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_12()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
// create a table and an index
TESTC_(Table.CreateTable(0, 1), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// select a column (the one used in index)
TESTC_(Table.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(cons.MakeConstraintName(), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Use the name of an already existing constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_13()
{
TBEGIN
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CUniqueCons UniqueCons;
CPrimaryKeyCons PKCons;
CCheckCons CheckCons;
CForeignKeyCons FKCons;
DBORDINAL rgCol[] = {1};
HRESULT hr;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a table
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
// create a unique constraint
TESTC_(UniqueCons.SetConstraint(&Table, 1), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), UniqueCons), S_OK);
// create a check constraint
CheckCons.SetLTCheckConstraint(&Table, 1, 60);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), CheckCons), S_OK);
// create a PK constraint
TESTC_(PKCons.SetConstraint(&Table, 1), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), PKCons), S_OK);
// create a FK constraint
TESTC_(FKCons.SetConstraint(&Table, NUMELEM(rgCol), rgCol,
&ReferencedTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), FKCons), S_OK);
// add the constraint again, this time on other column (if possible)
TESTC_(cons.SetConstraint(&Table, 2), S_OK);
odtLog << "Unique constraint duplicate unique constraint name\n";
cons.SetConstraintID(UniqueCons.GetConstraintID());
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
odtLog << "Unique constraint duplicate check constraint name\n";
cons.SetConstraintID(CheckCons.GetConstraintID());
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
odtLog << "Unique constraint duplicate primary key constraint name\n";
cons.SetConstraintID(PKCons.GetConstraintID());
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
odtLog << "Unique constraint duplicate foreign key constraint name\n";
cons.SetConstraintID(FKCons.GetConstraintID());
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
CHECK(Table.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Constraint is created in a different catalog
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_14()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
DBORDINAL indxCat = 0;
CCatalogs Catalogs(m_pIOpenRowset);
IDBProperties *pIDBProperties = NULL;
CPropSets PropSets;
WCHAR *pwszCurrentCatalog = NULL;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
TESTC_PROVIDER(SettableProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize));
TESTC_PROVIDER(1 < Catalogs.cCatalogs());
// create a table and an index
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// select column
TESTC_(Table.GetColInfo(1, col), S_OK);
// set DBID of the table to its qualified form
TESTC(DBKIND_NAME == Table.GetTableID().eKind);
TESTC(GetCatalogSchemaNames(Table.GetTableName(), &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, Table.GetTableName(), &pwszQualTableName),S_OK);
Table.SetTableName(pwszQualTableName);
// change the current catalog
TESTC(GetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize,
&pwszCurrentCatalog));
TESTC(NULL != pwszCurrentCatalog);
TESTC(VerifyInterface(m_pIDBInitialize, IID_IDBProperties, DATASOURCE_INTERFACE, (IUnknown**)&pIDBProperties));
if (0 == wcscmp(pwszCurrentCatalog, Catalogs[0]))
indxCat++;
CHECK(PropSets.AddProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)Catalogs[indxCat]), S_OK);
TESTC_PROVIDER(S_OK == pIDBProperties->SetProperties(PropSets, PropSets));
// alloc memory for column array
cons.AddColumn(col.GetColID());
// try to make column unique
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
if (CHECK(PropSets.SetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)pwszCurrentCatalog), S_OK))
CHECK(pIDBProperties->SetProperties(PropSets, PropSets), S_OK);
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
SAFE_FREE(pwszCurrentCatalog);
SAFE_RELEASE(pIDBProperties);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc create a unique constraint on a non empty table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_15()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// create a table and an index
TESTC_(Table.CreateTable(10, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// select column
TESTC_(AddUniqueConstraint(&Table, 1), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Create a unique constraints on a column that has doubled values
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_16()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// create a table and an index
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// double one of the rows
TESTC_PROVIDER(S_OK == Table.Insert(5));
TESTC_PROVIDER(S_OK == Table.Insert(5));
// add the constraint
TESTC_(AddUniqueConstraint(&Table, 1), DB_E_SCHEMAVIOLATION);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_17()
{
CAddUniqueConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Abort non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_18()
{
CAddUniqueConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Commit retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_19()
{
CAddUniqueConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Commit non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_UNIQUE::Variation_20()
{
CAddUniqueConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
int TCAddConstraint_UNIQUE::Variation_21() {
TBEGIN
CLimitTable Table;
TESTC_(Table.CheckUniqueKeyLimit(), S_OK);
CLEANUP:
TRETURN
}
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_UNIQUE::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_PRIMARYKEY)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_PRIMARYKEY - Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_PRIMARYKEY
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_PRIMARYKEY::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
// TO DO: Add your own code here
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Create a table and try to apply the constraint on each column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_1()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL index;
CPrimaryKeyCons cons;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
HRESULT hrExpected = S_OK;
DBORDINAL cColCount = 0,
cTotalLength = 0,
start = 1,
cTotalColsInTable = 0;
ULONG ulNumberOfTests = 0;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create the base table
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// build the constraint
cTotalColsInTable = Table.CountColumnsOnTable();
while(start < cTotalColsInTable) {
cTotalLength = 0;
hrExpected = S_OK;
cons.ReleaseColumnList();
for (index = start, cColCount = 0; index <= Table.CountColumnsOnTable() &&
cColCount < cMaxColsPerCons; index++, cColCount++)
{
CCol col;
DBORDINAL colSizeInBytes = 0; //how many bytes the column contributes into maximum size of constraint
TESTC_(Table.GetColInfo(index, col), S_OK);
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if(col.GetIsFixedLength() )
colSizeInBytes = col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1);
else
colSizeInBytes = 0;
if (col.GetIsLong() ||
cTotalLength + colSizeInBytes > cMaxColLengthPerCons)
continue;
cTotalLength += colSizeInBytes;
cons.AddColumn(col.GetColID());
}
if (cColCount)
{
ulNumberOfTests++;
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), hrExpected);
if (hrExpected == S_OK) {
CHECK(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
}
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), hrExpected);
if (hrExpected==S_OK)
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
}
start = index;
}
TESTC(ulNumberOfTests>0)
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Set a primary key constraint on each type of column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_2()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL index;
CPrimaryKeyCons cons;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
HRESULT hrExpected = S_OK;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// build the constraint
for (index=1; index <= Table.CountColumnsOnTable(); index++)
{
CCol col;
TESTC_(Table.GetColInfo(index, col), S_OK);
TESTC_(cons.ReleaseColumnList(), S_OK);
cons.AddColumn(col.GetColID());
odtLog << col.GetProviderTypeName() << "\n";
// Depending on the type of column, set return value
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if (col.GetIsLong() ||
(col.GetIsFixedLength() && (col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1) > cMaxColLengthPerCons)))
hrExpected = E_FAIL;
else
hrExpected = S_OK;
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), hrExpected);
if (hrExpected == S_OK) {
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
}
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), hrExpected);
if (hrExpected == S_OK)
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Create a primary key constraint. Drop it. Create a primary key using the same name as before.
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_3()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// build the constraint
// try to set all the columns as primary key
TESTC_(Table.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
ReleaseDBID(&pConsDesc->rgColumnList[0], FALSE);
TESTC_(Table.GetColInfo(2, col), S_OK);
DuplicateDBID(*col.GetColID(), &pConsDesc->rgColumnList[0]);
// create constraint with the same name as before, different column
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Create multiple-columned primary key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_4()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
TESTC_(Table.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(Table.GetColInfo(2, col), S_OK);
cons.AddColumn(col.GetColID());
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Create multiple primary key constraints using successive calls
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_5()
{
TBEGIN
HRESULT hr;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
CConsDescArray consArray;
CCol col;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// build the constraint
TESTC_(AddPrimaryKeyConstraint(&Table, 1), S_OK);
TESTC_(AddPrimaryKeyConstraint(&Table, 1), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
// add a first PK constraint
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
cons.AddColumn(&rgNewColumnDesc[1].dbcid);
consArray.AddConsDesc(cons);
// add a second PK constraint
CHECK(cons.MakeConstraintName(), S_OK);
cons.ReleaseColumnList();
cons.AddColumn(&rgNewColumnDesc[2].dbcid);
consArray.AddConsDesc(cons);
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Successive calls, lists of columns overlap
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_6()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
CPrimaryKeyCons cons2;
CCol col;
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// build the constraint
TESTC_(Table.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(Table.GetColInfo(2, col), S_OK);
cons2.AddColumn(col.GetColID());
// try create second constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons2), DB_E_DUPLICATECONSTRAINTID);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons2), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_7()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// identify a nullable column
TESTC_PROVIDER(S_OK == Table.GetColInfo(IsCColNullable, col));
CHECK(AddPrimaryKeyConstraint(&Table, col.GetColNum()), E_FAIL);
// try the same when creating a table
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), E_FAIL);
//
//{
// CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
// ReleaseDBID(pTableID, TRUE);
//}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a not nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_8()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add a primary key on a not nullable column
CHECK(AddPrimaryKeyConstraint(&Table, 1), S_OK);
// try the same when creating a table
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column with a default value
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_9()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
VARIANT value;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
Table.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
VariantInit(&value);
odtLog << "Default value on type " << rgNewColumnDesc[0].pwszTypeName << "\n";
GetDefaultValue(&rgNewColumnDesc[0], &value, &Table);
SetDefaultProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&value);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add a PK on a column with a default value
CHECK(AddPrimaryKeyConstraint(&Table, 1), S_OK);
// try the same when creating a table
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column defined as unique
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_10()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
TESTC_PROVIDER(SettableProperty(DBPROP_COL_UNIQUE, DBPROPSET_COLUMN, m_pIDBInitialize));
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_UNIQUE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_OPTIONAL);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TEST2C_(Table.CreateTable(0, 0), S_OK, DB_S_ERRORSOCCURRED);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add PK on a unique column
CHECK(AddPrimaryKeyConstraint(&Table, 1), S_OK);
// try the same when creating a table
CHECK(cons.MakeConstraintName(), S_OK);
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column defined as primary key => DB_E_DUPLICATECONSTRAINTID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_11()
{
TBEGIN
HRESULT hr;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CPrimaryKeyCons cons;
TESTC_PROVIDER(SettableProperty(DBPROP_COL_PRIMARYKEY, DBPROPSET_COLUMN, m_pIDBInitialize));
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_PRIMARYKEY,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_OPTIONAL);
Table.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.SetBuildColumnDesc(FALSE);
TEST2C_(Table.CreateTable(0, 0), S_OK, DB_S_ERRORSOCCURRED);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// since there already is a primary key on this table
// expect DB_E_DUPLICATECONSTRAINTID
CHECK(AddPrimaryKeyConstraint(&Table, 1), DB_E_DUPLICATECONSTRAINTID);
// try the same when creating a table
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
if (!CHECK(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_DUPLICATECONSTRAINTID) && SUCCEEDED(hr))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column that already has a primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_12()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col;
CPrimaryKeyCons cons;
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// identify a nullable column
TESTC_(Table.GetColInfo(1, col), S_OK);
// alloc memory for column array
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// another constraint ID
CHECK(cons.MakeConstraintName(), S_OK);
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_DUPLICATECONSTRAINTID);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column that is part of a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_13()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL indexCol = 1;
DBID *pTableID = NULL;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
CPrimaryKeyCons cons;
CForeignKeyCons consFK;
CConsDescArray consArray;
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
// create a base table without nullable columns and a reference table
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == ReferencedTable.CountColumnsOnTable())
// prepare and add the unique constraint on the referenced table
TESTC_(AddUniqueConstraint(&ReferencedTable, indexCol), S_OK);
// build the foreign key constraint, use corresponding columns in tables
CHECK(AddForeignKeyConstraint(&BaseTable, 1, &indexCol,
&ReferencedTable, 1, &indexCol, m_SupportedMatchType), S_OK);
// add the PK constraint on the BaseTable
CHECK(AddPrimaryKeyConstraint(&BaseTable, indexCol), S_OK);
// try the same on a table -> create a PK and a FK, their column lists are not disjoint
// add a first PK constraint
TESTC_(ReferencedTable.GetColInfo(indexCol, col), S_OK);
consFK.AddColumn(col.GetColID());
consFK.AddForeignKeyColumn(&rgNewColumnDesc[indexCol-1].dbcid);
consFK.SetReferencedTableID(&ReferencedTable.GetTableID());
consArray.AddConsDesc(consFK);
// add a second PK constraint
cons.AddColumn(&rgNewColumnDesc[indexCol-1].dbcid);
consArray.AddConsDesc(cons);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column that is part of an index
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_14()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL ulIndexCol = 1;
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 0, ulIndexCol), S_OK);
// add a PK constraint on the index column
TESTC_(AddPrimaryKeyConstraint(&Table, ulIndexCol), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column on a not empty table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_15()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 10), S_OK);
// add PK constraint
TESTC_(AddPrimaryKeyConstraint(&Table, 1), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint on a column that already has duplicates (for the whole key)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_16()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
// create a base table without nullable columns
TESTC_(CreateTableWithNoNullableColumns(&Table, 10), S_OK);
TESTC_(Table.Insert(7), S_OK);
// expect DB_E_SCHEMAVIOLATION because the table already contains duplicates
TESTC_(AddPrimaryKeyConstraint(&Table, 1), DB_E_SCHEMAVIOLATION);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Primary key constraint that has duplicates for a column in the key, but not for the whole key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_17()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
CCol col;
VARIANT value;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
HRESULT hr;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
Table.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
// create a new table with a NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
VariantInit(&value);
GetDefaultValue(&rgNewColumnDesc[0], &value, &Table);
SetDefaultProperty(&rgNewColumnDesc[0].rgPropertySets, &rgNewColumnDesc[0].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&value);
Table.SetColumnDesc(rgNewColumnDesc+1, m_cColumnDesc-1);
Table.SetBuildColumnDesc(FALSE);
SetProperty(&rgNewColumnDesc[1].rgPropertySets, &rgNewColumnDesc[1].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TEST2C_(hr = Table.CreateTable(10, 0), S_OK, DB_S_ERRORSOCCURRED);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TEST2C_(hr = m_pITableDefinition->AddColumn(&Table.GetTableID(),
rgNewColumnDesc, NULL), S_OK, DB_E_ERRORSOCCURRED);
TESTC(S_OK == hr);
// identify a nullable column
TESTC_(Table.GetColInfo(1, col), S_OK);
// build the primary key
cons.AddColumn(&rgNewColumnDesc[0].dbcid);
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.SetColumnDesc(NULL, 0);
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_18()
{
CAddPrimaryKeyConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Abort non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_19()
{
CAddPrimaryKeyConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Commit retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_20()
{
CAddPrimaryKeyConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Commit non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_21()
{
CAddPrimaryKeyConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Create PK in a different catalog
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_PRIMARYKEY::Variation_22()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
DBORDINAL indxCat = 0;
CCatalogs Catalogs(m_pIOpenRowset);
IDBProperties *pIDBProperties = NULL;
CPropSets PropSets;
WCHAR *pwszCurrentCatalog = NULL;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
TESTC_PROVIDER(SettableProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize));
TESTC_PROVIDER(1 < Catalogs.cCatalogs());
// create a table and an index
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// select column
TESTC_(Table.GetColInfo(1, col), S_OK);
// set DBID of the table to its qualified form
TESTC(DBKIND_NAME == Table.GetTableID().eKind);
TESTC(GetCatalogSchemaNames(Table.GetTableName(), &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, Table.GetTableName(), &pwszQualTableName),S_OK);
Table.SetTableName(pwszQualTableName);
// change the current catalog
TESTC(GetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize,
&pwszCurrentCatalog));
TESTC(NULL != pwszCurrentCatalog);
TESTC(VerifyInterface(m_pIDBInitialize, IID_IDBProperties, DATASOURCE_INTERFACE, (IUnknown**)&pIDBProperties));
if (0 == wcscmp(pwszCurrentCatalog, Catalogs[0]))
indxCat++;
CHECK(PropSets.AddProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)Catalogs[indxCat]), S_OK);
TESTC_PROVIDER(S_OK == pIDBProperties->SetProperties(PropSets, PropSets));
// alloc memory for column array
cons.AddColumn(col.GetColID());
// try to make column unique
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
if (CHECK(PropSets.SetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)pwszCurrentCatalog), S_OK))
CHECK(pIDBProperties->SetProperties(PropSets, PropSets), S_OK);
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
SAFE_FREE(pwszCurrentCatalog);
SAFE_RELEASE(pIDBProperties);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
int TCAddConstraint_PRIMARYKEY::Variation_23() {
TBEGIN
CLimitTable Table;
TESTC_(Table.CheckPrimaryKeyLimit(), S_OK);
CLEANUP:
TRETURN;
}
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_PRIMARYKEY::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_FOREIGNKEY)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_FOREIGNKEY - Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_FOREIGNKEY
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_FOREIGNKEY::Init()
{
m_pReferenceTable = NULL;
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC==NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
m_pReferenceTable = new CTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
TESTC_(m_pReferenceTable->CreateTable(0, 1), S_OK);
m_pReferenceTable->AddInfoFromColumnsSchemaRowset(m_pITDWC, m_pReferenceTable->GetTableName());
return TRUE;
}
CLEANUP:
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Simple foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_1()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col, col2;
DBORDINAL indexCol = 1;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
TESTC_(Table.CreateTable(0, 0), S_OK);
// select columns from tables
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
Table.BuildColumnDescs(&rgNewColumnDesc);
TESTC(Table.CountColumnsOnTable() == m_pReferenceTable->CountColumnsOnTable())
TESTC_(Table.GetColInfo(indexCol, col), S_OK);
TESTC_(m_pReferenceTable->GetColInfo(indexCol, col2), S_OK);
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(col2.GetColID());
cons.AddForeignKeyColumn(col.GetColID());
cons.SetReferencedTableID(&m_pReferenceTable->GetTableID());
// add the foreign key constraint
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Foregin key is made of several columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_2()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1, 2};
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CCol col;
DBORDINAL index;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// add the foreign key constraint
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try the same when creating a table
for (index=0; index < NUMELEM(rgCol); index++)
{
TESTC_(RefTable.GetColInfo(rgCol[index], col), S_OK);
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[index]-1].dbcid);
}
cons.SetReferencedTableID(&RefTable.GetTableID());
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Multiple foreign key constraints on a table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_3()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1, 2};
DBORDINAL rgCol2[] = {3, 4};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CConsDescArray consArray;
CCol col;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol2), rgCol2), S_OK);
// add the foreign key constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// set a second foreign constraint
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol2), rgCol2,
&RefTable, NUMELEM(rgCol2), rgCol2, m_SupportedMatchType), S_OK);
// try to create a table with 2 disjoint FK constraint
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(RefTable.GetColInfo(rgCol[1], col), S_OK);
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[0]-1].dbcid);
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[1]-1].dbcid);
cons.SetReferencedTableID(&RefTable.GetTableID());
consArray.AddConsDesc(cons);
TESTC_(cons.MakeConstraintName(), S_OK);
CHECK(cons.ReleaseColumnList(), S_OK);
CHECK(cons.ReleaseForeignKeyColumnList(), S_OK);
TESTC_(RefTable.GetColInfo(rgCol2[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(RefTable.GetColInfo(rgCol2[1], col), S_OK);
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol2[0]-1].dbcid);
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol2[1]-1].dbcid);
consArray.AddConsDesc(cons);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Multiple overlapping foreign key constraints
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_4()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1, 2};
DBORDINAL rgCol2[] = {3, 2};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CConsDescArray consArray;
CCol col;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol2), rgCol2), S_OK);
// add the foreign key constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// set a second foreign constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol2), rgCol2,
&RefTable, NUMELEM(rgCol2), rgCol2, m_SupportedMatchType), S_OK);
// try to create a table with 2 overlapping FK constraint
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(RefTable.GetColInfo(rgCol[1], col), S_OK);
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[0]-1].dbcid);
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[1]-1].dbcid);
cons.SetReferencedTableID(&RefTable.GetTableID());
consArray.AddConsDesc(cons);
TESTC_(cons.MakeConstraintName(), S_OK);
CHECK(cons.ReleaseColumnList(), S_OK);
CHECK(cons.ReleaseForeignKeyColumnList(), S_OK);
TESTC_(RefTable.GetColInfo(rgCol2[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(RefTable.GetColInfo(rgCol2[1], col), S_OK);
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol2[0]-1].dbcid);
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol2[1]-1].dbcid);
consArray.AddConsDesc(cons);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Create a foreign key on each column of the table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_5()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBORDINAL indexCol;
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
// create a new table with a NOT NULLABLE column
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
BaseTable.BuildColumnDescs(&rgNewColumnDesc);
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// set referenced table
cons.SetReferencedTableID(&RefTable.GetTableID());
// make room for columns id
for (indexCol = 1; indexCol <= BaseTable.CountColumnsOnTable(); indexCol++)
{
if (!CHECK(BaseTable.GetColInfo(indexCol, col), S_OK))
continue;
odtLog << col.GetProviderTypeName() << "\n";
// make the referenced columns unique
if (S_OK != AddUniqueConstraint(&RefTable, indexCol))
continue;
// build the foreign key constraint, use corresponding columns in tables
// set column on base table
cons.ReleaseForeignKeyColumnList();
cons.AddForeignKeyColumn(col.GetColID());
// set foreign column
if (!CHECK(RefTable.GetColInfo(indexCol, col), S_OK))
continue;
cons.ReleaseColumnList();
cons.AddColumn(col.GetColID());
// add the foreign key constraint
if (CHECK(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK))
{
// drop the constraint
CHECK(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
}
// try the same when creating a table
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Create a foreign key on all columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_6()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBORDINAL indexCol;
CUniqueCons consUnique;
ULONG_PTR uMaxColsInIndex = 0,
uAdded = 0,
uMaxIndexSize = 0,
uCurIndexSize = 0,
uColSizeInBytes = 0;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// set referenced table
cons.SetReferencedTableID(&RefTable.GetTableID());
if (SupportedProperty(DBPROP_MAXINDEXSIZE, DBPROPSET_DATASOURCEINFO, GetModInfo()->GetThisTestModule()->m_pIUnknown, DATASOURCE_INTERFACE))
TESTC(GetProperty(DBPROP_MAXINDEXSIZE, DBPROPSET_DATASOURCEINFO, GetModInfo()->GetThisTestModule()->m_pIUnknown, &uMaxIndexSize));
for (indexCol = 1; indexCol <= BaseTable.CountColumnsOnTable(); indexCol++)
{
// set column on base table
TESTC_(BaseTable.GetColInfo(indexCol, col), S_OK);
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if(col.GetIsFixedLength() )
uColSizeInBytes = col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1);
else
uColSizeInBytes = 0;
if (uMaxIndexSize && (uMaxIndexSize - uCurIndexSize) < uColSizeInBytes)
continue;
cons.AddForeignKeyColumn(col.GetColID());
// set foreign column
TESTC_(RefTable.GetColInfo(indexCol, col), S_OK);
cons.AddColumn(col.GetColID());
consUnique.AddColumn(col.GetColID());
uAdded++;
uCurIndexSize += uColSizeInBytes;
if (uMaxColsInIndex && uAdded == uMaxColsInIndex)
break;
}
// make the referenced columns unique
TESTC_(AddConstraintAndCheck(m_pITDWC, &RefTable.GetTableID(), consUnique), S_OK);
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Create foreign key and try to drop the reference table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_7()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CCol col;
DBORDINAL rgCol[] = {1};
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// add the foreign key constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try to drop the table or a column in the FK constraint
TESTC_PROVIDER(S_OK == RefTable.GetColInfo(rgCol[0], col));
CHECK(DropTableAndCheck(&RefTable.GetTableID()), DB_E_DROPRESTRICTED);
CHECK(DropColumnAndCheck(&RefTable.GetTableID(), col.GetColID()), DB_E_DROPRESTRICTED);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc On a nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_8()
{
TBEGIN
DBORDINAL rgCol[] = {1};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
CForeignKeyCons cons;
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[rgCol[0]-1].rgPropertySets, &rgNewColumnDesc[rgCol[0]-1].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
BaseTable.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// add the FK constraint on the NULLABLE column
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try the same when creating a table
cons.SetReferencedTableID(&RefTable.GetTableID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[0]-1].dbcid);
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc On a not nullable column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_9()
{
TBEGIN
DBORDINAL rgCol[] = {1};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
CForeignKeyCons cons;
CCol col;
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
SetProperty(&rgNewColumnDesc[rgCol[0]-1].rgPropertySets, &rgNewColumnDesc[rgCol[0]-1].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
BaseTable.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// add the FK constraint on the not NULLABLE column
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try the same when creating a table
cons.SetReferencedTableID(&RefTable.GetTableID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[0]-1].dbcid);
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc On a column having a default value
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_10()
{
TBEGIN
VARIANT value;
DBORDINAL rgCol[] = {1};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
DBID *pTableID = NULL;
CForeignKeyCons cons;
CCol col;
BaseTable.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
VariantInit(&value);
GetDefaultValue(&rgNewColumnDesc[rgCol[0]-1], &value, &BaseTable);
SetDefaultProperty(&rgNewColumnDesc[rgCol[0]-1].rgPropertySets, &rgNewColumnDesc[rgCol[0]-1].cPropertySets,
&value, DBPROPOPTIONS_REQUIRED); // might be not supported
VariantClear(&value);
BaseTable.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// add the FK constraint
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try the same when creating a table
cons.SetReferencedTableID(&RefTable.GetTableID());
cons.AddForeignKeyColumn(&rgNewColumnDesc[rgCol[0]-1].dbcid);
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, 1, cons, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc On a column defined as unique
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_11()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CForeignKeyCons consFK;
CUniqueCons cons;
CCol col, col2;
CConsDescArray consArray;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
BaseTable.BuildColumnDescs(&rgNewColumnDesc);
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// select a column
TESTC(BaseTable.CountColumnsOnTable() == RefTable.CountColumnsOnTable())
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, NUMELEM(rgCol), rgCol), S_OK);
// make the base column unique
TESTC_(AddUniqueConstraint(&BaseTable, NUMELEM(rgCol), rgCol), S_OK);
// add the FK constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try to create a table with a unique and a FK cons
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
TESTC_(BaseTable.GetColInfo(rgCol[0], col2), S_OK);
cons.AddColumn(col2.GetColID());
consArray.AddConsDesc(cons);
consFK.SetReferencedTableID(&RefTable.GetTableID());
consFK.AddForeignKeyColumn(col2.GetColID());
consFK.AddColumn(col.GetColID());
consArray.AddConsDesc(consFK);
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc On a primary key column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_12()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBID *pTableID = NULL;
CForeignKeyCons consFK;
CPrimaryKeyCons cons;
CCol col, col2;
CConsDescArray consArray;
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
BaseTable.BuildColumnDescs(&rgNewColumnDesc);
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, rgCol[0], (DBDEFERRABILITY)0), S_OK);
// make the base column unique
TESTC_(AddPrimaryKeyConstraint(&BaseTable, rgCol[0], (DBDEFERRABILITY)0), S_OK);
// add FK constraint
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
// try to create a table with a unique and a FK cons
TESTC_(RefTable.GetColInfo(rgCol[0], col), S_OK);
TESTC_(BaseTable.GetColInfo(rgCol[0], col2), S_OK);
cons.AddColumn(col2.GetColID());
consArray.AddConsDesc(cons);
consFK.SetReferencedTableID(&RefTable.GetTableID());
consFK.AddForeignKeyColumn(col2.GetColID());
consFK.AddColumn(col.GetColID());
consArray.AddConsDesc(consFK);
TESTC_(cons.MakeConstraintName(), S_OK);
if (CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
m_cColumnDesc, rgNewColumnDesc, consArray, consArray, IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK))
{
CHECK(DropTableAndCheck(pTableID, m_pITDWC), S_OK);
ReleaseDBID(pTableID, TRUE);
}
CLEANUP:
ReleaseColumnDesc(rgNewColumnDesc, m_cColumnDesc, TRUE);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc On a column that is part of the index
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_13()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
TESTC_(BaseTable.CreateTable(0, 1), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 1), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, 1, (DBDEFERRABILITY)0), S_OK);
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc On a table that is in another catalog
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_14()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CCatalogs Catalogs(m_pIOpenRowset);
WCHAR *pwszCurrentCatalog = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
WCHAR *pwszQualTableName = NULL;
TESTC_PROVIDER(SettableProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize));
TESTC_PROVIDER(1 < Catalogs.cCatalogs());
// store the name of the current catalog
TESTC(Catalogs.GetCurrentCatalog(&pwszCurrentCatalog));
// change the current catalog
TESTC_(Catalogs.ChangeCurrentCatalog(), S_OK);
// create the referenced table in this catalog
TESTC_PROVIDER(S_OK == ReferencedTable.CreateTable(0, 0));
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC(GetCatalogSchemaNames(ReferencedTable.GetTableName(), &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(BaseTable.GetQualifiedName(pwszCatalogName, pwszSchemaName, ReferencedTable.GetTableName(), &pwszQualTableName),S_OK);
ReferencedTable.SetTableName(pwszQualTableName);
// switch back the current catalog
TESTC_(Catalogs.SetCurrentCatalog(pwszCurrentCatalog), S_OK);
// create the base table
BaseTable.SetTableName(NULL);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// create the
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType), S_OK);
CLEANUP:
if (pwszCurrentCatalog)
// restore the name of the current catalog
COMPARE(Catalogs.SetCurrentCatalog(pwszCurrentCatalog), S_OK);
SAFE_FREE(pwszCurrentCatalog);
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Use different combination for update/delete rules, as well as match type
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_15()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
DBUPDELRULE rgUPDLValues[] = {DBUPDELRULE_NOACTION, DBUPDELRULE_CASCADE,
DBUPDELRULE_SETNULL, DBUPDELRULE_SETDEFAULT};
WCHAR *rgUPDLValuesText[] = {L"DBUPDELRULE_NOACTION", L"DBUPDELRULE_CASCADE",
L"DBUPDELRULE_SETNULL", L"DBUPDELRULE_SETDEFAULT"};
DBORDINAL indexDelete;
DBORDINAL indexUpdate;
DBMATCHTYPE rgMatchType[] = {DBMATCHTYPE_NONE, DBMATCHTYPE_FULL, DBMATCHTYPE_PARTIAL};
WCHAR *rgMatchTypeText[] = {L"DBMATCHTYPE_NONE", L"DBMATCHTYPE_FULL", L"DBMATCHTYPE_PARTIAL"};
DBORDINAL indexMatchType;
DBORDINAL cSuccess = 0;
HRESULT hr;
TESTC_(BaseTable.CreateTable(0, 1), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, 1, (DBDEFERRABILITY)0), S_OK);
for (indexDelete = 0; indexDelete < NUMELEM(rgUPDLValues); indexDelete++)
{
// all delete rules
odtLog << "\t" << rgUPDLValuesText[indexDelete] << "\n";
for (indexUpdate = 0; indexUpdate < NUMELEM(rgUPDLValues); indexUpdate++)
{
// all update rules
odtLog << "\t\t" << rgUPDLValuesText[indexUpdate] << "\n";
for (indexMatchType = 0; indexMatchType < NUMELEM(rgMatchType); indexMatchType++)
{
CForeignKeyCons cons;
// all match type rules
odtLog << "\t\t\t" << rgMatchTypeText[indexMatchType];
cons.SetConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol,
rgMatchType[indexMatchType],
rgUPDLValues[indexUpdate],
rgUPDLValues[indexDelete],
(DBDEFERRABILITY)0);
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons);
if (S_OK == hr)
{
odtLog << "\n";
cSuccess++;
CHECK(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(),
cons.GetConstraintID()), S_OK);
}
else if (DB_E_BADUPDATEDELETERULE != hr && DB_E_BADMATCHTYPE!= hr)
{
CHECK(hr, S_OK);
}
else
odtLog << "\tunsupported " << ((DB_E_BADUPDATEDELETERULE == hr) ? "rule" : "match type") << "\n";
}
}
}
TESTC(0 < cSuccess);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Referenced table name and base table names have maximum length
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_16()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
WCHAR *pwszTableName = NULL;
BaseTable.MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, BaseTable.GetTableName());
TESTC_(BaseTable.CreateTable(0, 0, pwszTableName), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, 1, (DBDEFERRABILITY)0), S_OK);
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
CLEANUP:
SAFE_FREE(pwszTableName);
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Columns in the foreign key (base table and reference table) have different names
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_17()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgNewColumnDesc = NULL;
DBORDINAL rgCol[] = {1};
// the name of the column should be different
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgNewColumnDesc);
ReleaseDBID(&rgNewColumnDesc[0].dbcid, FALSE);
rgNewColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgNewColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"AnotherColumn");
BaseTable.SetColumnDesc(rgNewColumnDesc, m_cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, 1, (DBDEFERRABILITY)0), S_OK);
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol), rgCol, m_SupportedMatchType), S_OK);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Different size in column lists (base table and referenced)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_18()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable RefTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCol[] = {1};
DBORDINAL rgCol2[] = {1, 2};
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(RefTable.CreateTable(0, 0), S_OK);
RefTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, RefTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&RefTable, 1, (DBDEFERRABILITY)0), S_OK);
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol2), rgCol2, m_SupportedMatchType), E_INVALIDARG);
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgCol), rgCol,
&RefTable, NUMELEM(rgCol2), rgCol2, m_SupportedMatchType), E_INVALIDARG);
CLEANUP:
BaseTable.DropTable();
RefTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Column types in base table and reference table are different
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_19()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {3};
CCol col;
HRESULT hr;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// find 2 columns of different types (DBTYPE_I4 and DBTYPE_R4)
TESTC_PROVIDER(S_OK == ReferencedTable.GetColInfo(col, DBTYPE_I4));
rgReferencedCol[0] = col.GetColNum();
TESTC_PROVIDER(S_OK == BaseTable.GetColInfo(col, DBTYPE_R4));
rgBaseCol[0] = col.GetColNum();
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
CHECK(ReferencedTable.GetColInfo(rgReferencedCol[0], col), S_OK);
cons.AddColumn(col.GetColID());
CHECK(BaseTable.GetColInfo(rgBaseCol[0], col), S_OK);
cons.AddForeignKeyColumn(col.GetColID());
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons, TRUE), DB_E_BADCONSTRAINTFORM);
if (S_OK == hr)
{
// challenge the constraint
TESTC_(ReferencedTable.Insert(12), S_OK);
TESTC_(BaseTable.Insert(12), S_OK);
}
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Invalid value for the update rule
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_20()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, 0xFF), DB_E_BADUPDATEDELETERULE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Invalid value for the delete rule
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_21()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, DBUPDELRULE_NOACTION, 0xFF), DB_E_BADUPDATEDELETERULE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Invalid value for the MatchType
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_22()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
CHECK(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
0xFF), DB_E_BADMATCHTYPE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Inexistent column names in the referenced table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_23()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons cons;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(cons.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// release the referenced column and set inexistent name
SAFE_FREE(((DBCONSTRAINTDESC*)cons)->rgColumnList[0].uName.pwszName);
((DBCONSTRAINTDESC*)cons)->rgColumnList[0].uName.pwszName = wcsDuplicate(L"NuExista");
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Inexistent column name in the base table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_24()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons cons;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(cons.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// release the referenced column and set inexistent name
SAFE_FREE(((DBCONSTRAINTDESC*)cons)->rgForeignKeyColumnList[0].uName.pwszName);
((DBCONSTRAINTDESC*)cons)->rgForeignKeyColumnList[0].uName.pwszName = wcsDuplicate(L"NuExista");
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_NOCOLUMN);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Inexistent base table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_25()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons cons;
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// since base table name has to be inexistent, use reference table name instead
TESTC_(cons.SetConstraint(&ReferencedTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
TESTC_(BaseTable.MakeTableName(NULL), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Inexistent reference table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_26()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons cons;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// since base table name has to be inexistent, use reference table name instead
TESTC_(cons.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&BaseTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// fill-in an inexistent table name
TESTC_(ReferencedTable.MakeTableName(NULL), S_OK);
ReleaseDBID(((DBCONSTRAINTDESC*)cons)->pReferencedTableID, FALSE);
TESTC_(DuplicateDBID(ReferencedTable.GetTableID(), ((DBCONSTRAINTDESC*)cons)->pReferencedTableID), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_NOTABLE);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc NULL pConstraintID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_27()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
CForeignKeyCons cons;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
TESTC_(cons.SetConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol, m_SupportedMatchType), S_OK);
// release pConstraintID
ReleaseDBID(((DBCONSTRAINTDESC*)cons)->pConstraintID, TRUE);
((DBCONSTRAINTDESC*)cons)->pConstraintID = NULL;
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc Referenced col list is not a unique / pk constraint => failure
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_28()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col, col2;
DBORDINAL indexCol = 1;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// select columns from tables
TESTC(BaseTable.CountColumnsOnTable() == ReferencedTable.CountColumnsOnTable())
TESTC_(BaseTable.GetColInfo(indexCol, col), S_OK);
TESTC_(ReferencedTable.GetColInfo(indexCol, col2), S_OK);
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(col2.GetColID());
cons.AddForeignKeyColumn(col.GetColID());
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), E_FAIL);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Create a foreign key and then insert a NULL value for one of the fk columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_29()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBORDINAL rgCols[] = {1, 2, 3};
IRowsetChange *pIRowsetChange = NULL;
DBMATCHTYPE rgMatchType[] = {DBMATCHTYPE_NONE, DBMATCHTYPE_FULL, DBMATCHTYPE_PARTIAL};
WCHAR *rgMatchTypeText[] = {L"DBMATCHTYPE_NONE", L"DBMATCHTYPE_FULL", L"DBMATCHTYPE_PARTIAL"};
DBORDINAL indexMatchType;
DBORDINAL cSuccess = 0;
HRESULT hr;
const DBORDINAL cProp = 1;
DBPROP rgProp[cProp];
const DBORDINAL cPropSets = 1;
DBPROPSET rgPropSets[cPropSets];
rgPropSets[0].guidPropertySet = DBPROPSET_ROWSET;
rgPropSets[0].cProperties = 1;
rgPropSets[0].rgProperties = rgProp;
memset(rgProp, 0, sizeof(DBPROP));
rgProp[0].dwPropertyID = DBPROP_UPDATABILITY;
rgProp[0].vValue.vt = VT_I4;
V_I4(&rgProp[0].vValue) = DBPROPVAL_UP_INSERT;
CList<WCHAR *,WCHAR *> NativeTypesList;
CList<DBTYPE,DBTYPE> ProviderTypesList;
DBCOLUMNDESC *rgColumnDesc = NULL;
BaseTable.CreateTypeColInfo(NativeTypesList, ProviderTypesList);
TESTC_PROVIDER(2 < m_cColumnDesc);
// create a new table with a NOT NULLABLE column
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
SetProperty(&rgColumnDesc[1].rgPropertySets, &rgColumnDesc[1].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
SetProperty(&rgColumnDesc[2].rgPropertySets, &rgColumnDesc[2].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_TRUE,
DBPROPOPTIONS_REQUIRED);
BaseTable.SetColumnDesc(rgColumnDesc, m_cColumnDesc);
BaseTable.SetBuildColumnDesc(FALSE);
TESTC_PROVIDER(S_OK == BaseTable.CreateTable(0, 0));
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(CreateTableWithNoNullableColumns(&ReferencedTable, 5, 0), S_OK);
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgCols), rgCols, (DBDEFERRABILITY)0), S_OK);
for (indexMatchType = 0; indexMatchType < NUMELEM(rgMatchType); indexMatchType++)
{
CForeignKeyCons cons;
// all match type rules
odtLog << "\t\t\t" << rgMatchTypeText[indexMatchType];
cons.SetConstraint(&BaseTable, NUMELEM(rgCols), rgCols,
&ReferencedTable, NUMELEM(rgCols), rgCols,
rgMatchType[indexMatchType],
DBUPDELRULE_NOACTION,
DBUPDELRULE_NOACTION,
(DBDEFERRABILITY)0);
hr = AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons);
if (S_OK == hr)
{
odtLog << "\n";
cSuccess++;
{
// open a rowset on the base table
TESTC_(g_pIOpenRowset->OpenRowset(NULL, &BaseTable.GetTableID(), NULL,
IID_IRowsetChange, cPropSets, rgPropSets, (IUnknown**)&pIRowsetChange), S_OK);
// try to insert a NULL in the second column
// this should succeed if the match type is partial and the rest
// of the key matches a rows in the referenced table
CHECK(Insert(3, pIRowsetChange, 1, rgCols + 1, &BaseTable),
(DBMATCHTYPE_FULL != rgMatchType[indexMatchType])? S_OK: DB_E_INTEGRITYVIOLATION);
CHECK(Insert(3, pIRowsetChange, 3, rgCols, &BaseTable), S_OK);
//(DBMATCHTYPE_FULL == rgMatchType[indexMatchType])? S_OK: DB_E_INTEGRITYVIOLATION);
CHECK(Insert(32, pIRowsetChange, 1, rgCols + 1, &BaseTable),
(DBMATCHTYPE_NONE == rgMatchType[indexMatchType])? S_OK: DB_E_INTEGRITYVIOLATION);
SAFE_RELEASE(pIRowsetChange);
}
CHECK(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(),
cons.GetConstraintID()), S_OK);
}
else if (DB_E_BADMATCHTYPE!= hr)
{
CHECK(hr, S_OK);
}
else
odtLog << "\tunsupported " << ((DB_E_BADUPDATEDELETERULE == hr) ? "rule" : "match type") << "\n";
}
TESTC(0 < cSuccess);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc The referenced table and the base table are the same
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_30()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col, col2;
DBORDINAL indexCol = 1;
HRESULT hr;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc;
DuplicateColumnDesc(m_rgColumnDesc, 1, &rgColumnDesc);
ReleaseDBID(&rgColumnDesc[0].dbcid, FALSE);
rgColumnDesc[0].dbcid.eKind = DBKIND_NAME;
rgColumnDesc[0].dbcid.uName.pwszName = wcsDuplicate(L"NewColumn");
ReleaseAllColumnPropSets(rgColumnDesc, 1);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TESTC_(AddUniqueConstraint(&Table, indexCol), S_OK);
TESTC_(AddColumnAndCheck(&Table.GetTableID(), rgColumnDesc, NULL, m_pITDWC), S_OK);
// select columns from tables
TESTC_(Table.GetColInfo(indexCol, col), S_OK);
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
cons.SetReferencedTableID(&Table.GetTableID());
// add the foreign key constraint
hr = AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons);
TEST2C_(hr, S_OK, DB_E_BADMATCHTYPE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, 1);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc The base and referenced tables are temporary tables
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_31()
{
TBEGIN
CCol col;
DBORDINAL indexCol = 1;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CUniqueCons UniqueCons;
DBID *pBaseTableID = NULL;
DBID *pReferencedTableID = NULL;
DBPROPSET rgPropSets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
TESTC_PROVIDER(SettableProperty(DBPROP_TBL_TEMPTABLE, DBPROPSET_TABLE));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// temp table, TableID generated by provider
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
TESTC_(CreateAndCheckTable(m_pITDWC, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowset, NUMELEM(rgPropSets), rgPropSets, &pReferencedTableID, NULL), S_OK);
UniqueCons.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(AddConstraintAndCheck(m_pITDWC, pReferencedTableID, UniqueCons), S_OK);
TESTC_(CreateAndCheckTable(m_pITDWC, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowset, NUMELEM(rgPropSets), rgPropSets, &pBaseTableID, NULL), S_OK);
// select columns from tables
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(&rgColumnDesc[0].dbcid);
cons.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
cons.SetReferencedTableID(pReferencedTableID);
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, pBaseTableID, cons), S_OK);
CLEANUP:
DropTableAndCheck(pBaseTableID);
DropTableAndCheck(pReferencedTableID);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pReferencedTableID, TRUE);
ReleaseDBID(pBaseTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc Base table is a temporary table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_32()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col;
DBORDINAL indexCol = 1;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
DBID *pBaseTableID = NULL;
DBPROPSET rgPropSets[1];
DBPROP rgProp[1];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
TESTC_PROVIDER(SettableProperty(DBPROP_TBL_TEMPTABLE, DBPROPSET_TABLE));
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
// temp table, TableID generated by provider
FILL_PROP_SET(rgPropSets[0], NUMELEM(rgProp), rgProp, DBPROPSET_TABLE);
FILL_PROP(rgProp[0], DBPROP_TBL_TEMPTABLE, VT_BOOL, V_BOOL, VARIANT_TRUE, DBPROPOPTIONS_REQUIRED);
TESTC_(CreateAndCheckTable(m_pITDWC, NULL, NULL, cColumnDesc, rgColumnDesc,
IID_IRowset, NUMELEM(rgPropSets), rgPropSets, &pBaseTableID, NULL), S_OK);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, indexCol), S_OK);
// select columns from tables
TESTC(ReferencedTable.CountColumnsOnTable() == cColumnDesc)
TESTC_(ReferencedTable.GetColInfo(indexCol, col), S_OK);
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(col.GetColID());
cons.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, pBaseTableID, cons), S_OK);
CLEANUP:
DropTableAndCheck(pBaseTableID);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pBaseTableID, TRUE);
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(33)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_33()
{
CAddFKConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(34)
//*-----------------------------------------------------------------------
// @mfunc Abort non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_34()
{
CAddFKConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(35)
//*-----------------------------------------------------------------------
// @mfunc Commit retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_35()
{
CAddFKConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(36)
//*-----------------------------------------------------------------------
// @mfunc Commit non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_36()
{
CAddFKConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(37)
//*-----------------------------------------------------------------------
// @mfunc The base table is already populated and the referenced one is empty => DB_E_SCHEMAVIOLATION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_FOREIGNKEY::Variation_37()
{
TBEGIN
CTable BaseTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCol col, col2;
DBORDINAL indexCol = 1;
CForeignKeyCons cons(NULL, m_SupportedMatchType);
TESTC_(BaseTable.CreateTable(5, 0), S_OK);
// select columns from tables
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC(BaseTable.CountColumnsOnTable() == m_pReferenceTable->CountColumnsOnTable())
TESTC_(BaseTable.GetColInfo(indexCol, col), S_OK);
TESTC_(m_pReferenceTable->GetColInfo(indexCol, col2), S_OK);
// build the foreign key constraint, use corresponding columns in tables
cons.AddColumn(col2.GetColID());
cons.AddForeignKeyColumn(col.GetColID());
cons.SetReferencedTableID(&m_pReferenceTable->GetTableID());
// add the foreign key constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), DB_E_SCHEMAVIOLATION);
CLEANUP:
BaseTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
int TCAddConstraint_FOREIGNKEY::Variation_38() {
TBEGIN
CLimitTable Table;
TESTC_(Table.CheckForeignKeyLimit(), S_OK);
CLEANUP:
TRETURN
}
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_FOREIGNKEY::Terminate()
{
if (m_pReferenceTable)
m_pReferenceTable->DropTable();
delete m_pReferenceTable;
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_CHECK)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_CHECK - Testcase for ITableDefinitionWithConstraints::AddConstraint used with DBCONSTRAINTTYPE_UNIQUE
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_CHECK::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Add simple check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_1()
{
TBEGIN
HRESULT hr;
IRowsetChange *pIRowsetChange = NULL;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
DBORDINAL rgNULLCols[] = {1};
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
Table.GetTableID().eKind? Table.GetTableID().uName.pwszName: NULL);
// get the first column of the table
cons.SetIsNotNULLCheckConstraint(&Table, rgNULLCols[0]);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TEST2C_(hr = m_pIOpenRowset->OpenRowset(NULL, &Table.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK, E_NOINTERFACE);
TESTC_PROVIDER(S_OK == hr);
// try to insert a null value in a not null column
TESTC_(hr = Insert(0, pIRowsetChange, NUMELEM(rgNULLCols), rgNULLCols), DB_E_INTEGRITYVIOLATION);
TESTC_(Table.GetColInfo(rgNULLCols[0], col), S_OK);
TEST2C_(hr = DropColumnAndCheck(&Table.GetTableID(), col.GetColID()), S_OK, DB_E_DROPRESTRICTED);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Add 2 check constraints on the same column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_2()
{
TBEGIN
CCheckCons cons;
DBORDINAL indexCol = 1;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// get the first column of the table
TESTC_(cons.SetIsNotNULLCheckConstraint(&Table, indexCol), S_OK);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// change the name of the constraint helper object
CHECK(cons.MakeConstraintName(), S_OK);
// create the text of the constraint
TESTC_(cons.SetLTCheckConstraint(&Table, indexCol, 2), S_OK);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Add check constraint for each column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_3()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
DBORDINAL indexCol;
HRESULT hrExpected = S_OK;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
for (indexCol = 0; indexCol < Table.CountColumnsOnTable(); indexCol++)
{
// get the first column of the table
TESTC_(Table.GetColInfo(indexCol+1, col), S_OK);
// change the name of the constraint helper object
cons.SetConstraintName(col.GetColName());
CHECK(cons.MakeConstraintName(), S_OK);
// create the text of the constraint
if (S_OK != cons.SetLTCheckConstraint(&Table, indexCol+1, 2))
CHECK(cons.SetIsNotNULLCheckConstraint(&Table, indexCol+1), S_OK);
// Check Constraints on BLOBs should fail
if (col.GetIsLong())
hrExpected = E_FAIL;
else
hrExpected = S_OK;
odtLog << col.GetColName() << "\t -> " << (hrExpected==S_OK ? "S_OK" : "E_FAIL") << "\n";
// add the constraint and check its addition
CHECK(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), hrExpected);
}
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Check constraint is always TRUE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_4()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons(L"TRUE");
CWString wszText;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add the constraint and check its addition
TESTC_(Table.GetColInfo(1, col), S_OK);
wszText = col.GetColName();
wszText + L" IS NULL OR ";
wszText + col.GetColName();
wszText + L" IS NOT NULL";
cons.SetConstraintText((LPWSTR)(LPCWSTR)wszText);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Check constraint is always false
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_5()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons(L"FALSE");
CWString wszText;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add the constraint and check its addition
TESTC_(Table.GetColInfo(1, col), S_OK);
wszText = col.GetColName();
wszText + L" IS NULL AND ";
wszText + col.GetColName();
wszText + L" IS NOT NULL";
cons.SetConstraintText((LPWSTR)(LPCWSTR)wszText);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Long text for the check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_6()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
const DBORDINAL cTextLen = 1001;
WCHAR wszText[cTextLen];
CCol col;
CWString wszText1;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TESTC_(Table.GetColInfo(1, col), S_OK);
wszText1 = col.GetColName();
wszText1 + L" IS NULL";
swprintf(wszText, L"%1000s", (LPCWSTR)wszText1);
cons.SetConstraintText(wszText);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Check constraint is made of white characters
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_7()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons(L" \t");
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), E_FAIL);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Maximum length for the table name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_8()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
WCHAR *pwszTableName = NULL;
// set a long table name
m_pTable->MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, m_pTable->GetTableName());
TESTC_(Table.CreateTable(0, 0, pwszTableName), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create the text of the constraint
CHECK(cons.SetLTCheckConstraint(&Table, 1, 5), S_OK);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
SAFE_FREE(pwszTableName);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Create the constraint, drop it, readd it with different text
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_9()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
// create a table with an index
TESTC_(Table.CreateTable(0, 1), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create the text of the constraint
CHECK(cons.SetLTCheckConstraint(&Table, 1, 5), S_OK);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// set a different text
CHECK(cons.SetIsNotNULLCheckConstraint(&Table, 2), S_OK);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Use inexistent column names in the check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_10()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons(L"InexistentCol < 10");
CCol col;
// create a table with an index
TESTC_(Table.CreateTable(0, 1), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCOLUMN);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Use qualified table column with different table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_11()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable Table2(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszColValue = NULL;
CWString wszText;
HRESULT hr = S_OK;
DBCOLUMNDESC *rgColumnDesc = NULL;
// create a table with an index
TESTC_(Table.CreateTable(0, 1), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
Table.BuildColumnDescs(&rgColumnDesc);
//Second table should have the same columns' names
Table2.SetColumnDesc(rgColumnDesc, Table.CountColumnsOnTable());
Table2.SetBuildColumnDesc(FALSE);
TESTC_(Table2.CreateTable(0, 1), S_OK);
Table2.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table2.GetTableName());
// get the first column of the table
TESTC_(Table2.GetColInfo(1 , col), S_OK);
// create the text of the constraint
TESTC_(Table.GetLiteralAndValue(col, &pwszColValue, rand(), col.GetColNum(), PRIMARY), S_OK);
wszText = Table2.GetTableName();
wszText + L".";
wszText + col.GetColName();
wszText + L" < ";
wszText + pwszColValue;
cons.SetConstraintText((LPWSTR)(LPCWSTR)wszText);
// add the constraint and check its addition
//Note: according to the spec provider can return E_FAIL or DB_E_NOCOLUMN when
// column referenced by pwszConstraintText does not exist
// DB_E_BADCONSTRAINTFORM can not be retunred in this case
//TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_BADCONSTRAINTFORM);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCOLUMN);
CLEANUP:
SAFE_FREE(pwszColValue);
Table.DropTable();
Table2.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Set a check condition on an index column
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_12()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
DBORDINAL indexCol = 1;
// create a table with an index
TESTC_(Table.CreateTable(0, indexCol), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
CHECK(cons.SetLTCheckConstraint(&Table, indexCol, 7), S_OK);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc pwszConstraintText is NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_13()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
cons.SetConstraintText(NULL);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_BADCONSTRAINTFORM);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc pwszConstraintText is an empty string
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_14()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons(L"");
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), E_FAIL);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Abort retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_15()
{
CAddCheckConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Abort non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_16()
{
CAddCheckConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Commit retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_17()
{
CAddCheckConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Commit non retaining
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_18()
{
CAddCheckConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Table is populated with rows that break the constraint to be added => DB_E_SCHEMAVIOLATION
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_CHECK::Variation_19()
{
TBEGIN
HRESULT hr;
IRowsetChange *pIRowsetChange = NULL;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
DBORDINAL rgNULLCols[1];
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NOT NULL";
TESTC_(Table.CreateTable(5, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITableDefinition,
Table.GetTableID().eKind? Table.GetTableID().uName.pwszName: NULL);
// get the first column of the table
TESTC_(Table.GetColInfo(1 , col), S_OK);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
// add a row with a NULL first column
TEST2C_(hr = m_pIOpenRowset->OpenRowset(NULL, &Table.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK, E_NOINTERFACE);
TESTC_PROVIDER(S_OK == hr);
// try to insert a null value in a not null column
rgNULLCols[0] = col.GetColNum();
TESTC_(hr = Insert(0, pIRowsetChange, NUMELEM(rgNULLCols), rgNULLCols), S_OK);
// try to add the constraint
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_SCHEMAVIOLATION);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
SAFE_FREE(pwszConstraintText);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
int TCAddConstraint_CHECK::Variation_20() {
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
DBORDINAL indxCat = 0;
CCatalogs Catalogs(m_pIOpenRowset);
IDBProperties *pIDBProperties = NULL;
CPropSets PropSets;
WCHAR *pwszCurrentCatalog = NULL;
WCHAR *pwszQualTableName = NULL;
WCHAR *pwszCatalogName = NULL;
WCHAR *pwszSchemaName = NULL;
TESTC_PROVIDER(SettableProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize));
TESTC_PROVIDER(1 < Catalogs.cCatalogs());
// create a table and an index
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// select column
TESTC_(Table.GetColInfo(1, col), S_OK);
// set DBID of the table to its qualified form
TESTC(DBKIND_NAME == Table.GetTableID().eKind);
TESTC(GetCatalogSchemaNames(Table.GetTableName(), &pwszCatalogName, &pwszSchemaName));
//Construct a fully Qualified TableName...
TESTC_(m_pTable->GetQualifiedName(pwszCatalogName, pwszSchemaName, Table.GetTableName(), &pwszQualTableName),S_OK);
Table.SetTableName(pwszQualTableName);
// change the current catalog
TESTC(GetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, m_pIDBInitialize,
&pwszCurrentCatalog));
TESTC(NULL != pwszCurrentCatalog);
TESTC(VerifyInterface(m_pIDBInitialize, IID_IDBProperties, DATASOURCE_INTERFACE, (IUnknown**)&pIDBProperties));
if (0 == wcscmp(pwszCurrentCatalog, Catalogs[0]))
indxCat++;
CHECK(PropSets.AddProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)Catalogs[indxCat]), S_OK);
TESTC_PROVIDER(S_OK == pIDBProperties->SetProperties(PropSets, PropSets));
// alloc memory for column array
cons.SetIsNotNULLCheckConstraint(&Table, col.GetColNum());
// try to make column unique
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
if (CHECK(PropSets.SetProperty(DBPROP_CURRENTCATALOG, DBPROPSET_DATASOURCE, VT_BSTR, (LPVOID)pwszCurrentCatalog), S_OK))
CHECK(pIDBProperties->SetProperties(PropSets, PropSets), S_OK);
SAFE_FREE(pwszCatalogName);
SAFE_FREE(pwszSchemaName);
SAFE_FREE(pwszQualTableName);
SAFE_FREE(pwszCurrentCatalog);
SAFE_RELEASE(pIDBProperties);
Table.DropTable();
TRETURN
}
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_CHECK::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_Deferrability)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_Deferrability - Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_Deferrability::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Immediate unique constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_1()
{
TBEGIN
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(Table.CreateTable(3, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create an immediate unique constraint
TESTC_(AddUniqueConstraint(&Table, 1, (DBDEFERRABILITY)0), S_OK);
// check that adding row with seed 2 again will fail
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Defferable unique constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_2()
{
TBEGIN
HRESULT hr;
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(Table.CreateTable(3, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create a deferrable unique constraint
TEST2C_(hr = AddUniqueConstraint(&Table, 1, DBDEFERRABILITY_DEFERRABLE), S_OK, DB_E_BADDEFERRABILITY);
// check that adding row with seed 2 again will fail
if (S_OK == hr)
{
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
}
else
odtLog << "Deferrable unique constraints are not supported\n";
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Deffered unique constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_3()
{
TBEGIN
HRESULT hr;
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(Table.CreateTable(3, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create an deferred unique constraint
TEST2C_(hr = AddUniqueConstraint(&Table, 1,
DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED), S_OK, DB_E_BADDEFERRABILITY);
// check that adding row with seed 2 again will fail
if (S_OK == hr)
{
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
}
else
odtLog << "Deferred unique constraints are not supported\n";
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Bad deferrability value unique constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_4()
{
TBEGIN
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(Table.CreateTable(0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// create a unique constraint
TESTC_(AddUniqueConstraint(&Table, 1,
~(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED)), DB_E_BADDEFERRABILITY);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Immediate primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_5()
{
TBEGIN
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(CreateTableWithNoNullableColumns(&Table, 3), S_OK);
// create an immediate unique constraint
TESTC_(AddPrimaryKeyConstraint(&Table, 1, (DBDEFERRABILITY)0), S_OK);
// check that adding row with seed 2 again will fail
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Deferrable primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_6()
{
TBEGIN
HRESULT hr;
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(CreateTableWithNoNullableColumns(&Table, 3), S_OK);
// create a deferrable unique constraint
TEST2C_(hr = AddPrimaryKeyConstraint(&Table, 1, DBDEFERRABILITY_DEFERRABLE), S_OK, DB_E_BADDEFERRABILITY);
// check that adding row with seed 2 again will fail
if (S_OK == hr)
{
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
}
else
odtLog << "Deferrable primary key constraints are not supported\n";
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Deferred primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_7()
{
TBEGIN
HRESULT hr;
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(CreateTableWithNoNullableColumns(&Table, 3), S_OK);
// create an deferred primary key constraint
TEST2C_(hr = AddPrimaryKeyConstraint(&Table, 1,
DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED), S_OK, DB_E_BADDEFERRABILITY);
// check that adding row with seed 2 again will fail
if (S_OK == hr)
{
TESTC_(Table.Insert(2), DB_E_INTEGRITYVIOLATION);
}
else
odtLog << "Deferred primary key constraints are not supported\n";
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Bad deferrability value primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_8()
{
TBEGIN
CTable Table(m_pITDWC, (LPWSTR)gwszModuleName);
// create a table
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// create a primary key constraint
TESTC_(AddPrimaryKeyConstraint(&Table, 1,
~(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED)), DB_E_BADDEFERRABILITY);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Immediate foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_9()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
// create a table
TESTC_(BaseTable.CreateTable(0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// create a unique constraint in the refereced table
TESTC_PROVIDER(S_OK == AddUniqueConstraint(&ReferencedTable, 1));
// create an immediate foreign key constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, DBUPDELRULE_NOACTION, DBUPDELRULE_NOACTION,
(DBDEFERRABILITY)0), S_OK);
// check that adding row with seed 2 again will fail
TESTC_(BaseTable.Insert(10), DB_E_INTEGRITYVIOLATION);
// check adding row in the referenced table is ok
TESTC_(ReferencedTable.Insert(10), S_OK);
TESTC_(BaseTable.Insert(10), S_OK);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Deferrable foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_10()
{
TBEGIN
HRESULT hr;
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
// create a table
TESTC_(BaseTable.CreateTable(0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// create a unique constraint in the refereced table
TESTC_PROVIDER(S_OK == AddUniqueConstraint(&ReferencedTable, 1));
// create a deferrable foreign key constraint
TEST2C_(hr = AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, DBUPDELRULE_NOACTION, DBUPDELRULE_NOACTION,
DBDEFERRABILITY_DEFERRABLE), S_OK, DB_E_BADDEFERRABILITY);
if (S_OK == hr)
{
// check that adding row with seed 2 again will fail
TESTC_(BaseTable.Insert(2), DB_E_INTEGRITYVIOLATION);
// check adding row in the referenced table is ok
TESTC_(ReferencedTable.Insert(2), S_OK);
TESTC_(BaseTable.Insert(2), S_OK);
}
else
odtLog << "Deferrable foreign key not supported\n";
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Deferred foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_11()
{
TBEGIN
HRESULT hr;
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
// create a table
TESTC_(BaseTable.CreateTable(0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// create a unique constraint in the refereced table
TESTC_PROVIDER(S_OK == AddUniqueConstraint(&ReferencedTable, 1));
// create a deferrable foreign key constraint
TEST2C_(hr = AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, DBUPDELRULE_NOACTION, DBUPDELRULE_NOACTION,
DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED),
S_OK, DB_E_BADDEFERRABILITY);
if (S_OK == hr)
{
// check that adding row with seed 2 again will fail
TESTC_(BaseTable.Insert(2), S_OK);
// check adding row in the referenced table is ok
TESTC_(ReferencedTable.Insert(2), S_OK);
TESTC_(BaseTable.Insert(2), S_OK);
}
else
odtLog << "Deferred foreign key not supported\n";
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Bad deferrability value foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_12()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBORDINAL rgBaseCol[] = {1};
DBORDINAL rgReferencedCol[] = {1};
// create a table
TESTC_(BaseTable.CreateTable(0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// create a unique constraint in the refereced table
TESTC_PROVIDER(S_OK == AddUniqueConstraint(&ReferencedTable, 1));
// create an immediate foreign key constraint
TESTC_(AddForeignKeyConstraint(&BaseTable, NUMELEM(rgBaseCol), rgBaseCol,
&ReferencedTable, NUMELEM(rgReferencedCol), rgReferencedCol,
m_SupportedMatchType, DBUPDELRULE_NOACTION, DBUPDELRULE_NOACTION,
~(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED)), DB_E_BADDEFERRABILITY);
// check adding row in the referenced table is ok
TESTC_(ReferencedTable.Insert(2), S_OK);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Immediate check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_13()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// get the first column of the table
TESTC_(Table.GetColInfo(1 , col), S_OK);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
cons.SetDeferrability((DBDEFERRABILITY)0);
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// add a row that does not have NULL in the checked column
TESTC_PROVIDER(2 < Table.CountColumnsOnTable());
TESTC_(Table.Insert(3), DB_E_INTEGRITYVIOLATION);
CLEANUP:
SAFE_FREE(pwszConstraintText);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Deferrable check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_14()
{
TBEGIN
HRESULT hr;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// get the first column of the table
TESTC_(Table.GetColInfo(1 , col), S_OK);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
cons.SetDeferrability(DBDEFERRABILITY_DEFERRABLE);
// add the constraint and check its addition
TEST2C_(hr = AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK, DB_E_BADDEFERRABILITY);
if (S_OK == hr)
{
// add a row that does not have NULL in the checked column
TESTC_PROVIDER(2 < Table.CountColumnsOnTable());
TESTC_(Table.Insert(3), DB_E_INTEGRITYVIOLATION);
}
else
odtLog << "Deferrable check constraints are not supported\n";
CLEANUP:
SAFE_FREE(pwszConstraintText);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Deferred check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_15()
{
TBEGIN
HRESULT hr;
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// get the first column of the table
TESTC_(Table.GetColInfo(1 , col), S_OK);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
cons.SetDeferrability(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED);
// add the constraint and check its addition
TEST2C_(hr = AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK, DB_E_BADDEFERRABILITY);
if (S_OK == hr)
{
// add a row that does not have NULL in the checked column
TESTC_(Table.Insert(3), S_OK);
}
else
odtLog << "Deferred check constraints are not supported\n";
CLEANUP:
SAFE_FREE(pwszConstraintText);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Bad deferrability value check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Deferrability::Variation_16()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// get the first column of the table
TESTC_(Table.GetColInfo(1 , col), S_OK);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColName()) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColName());
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
cons.SetDeferrability(~(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED));
// add the constraint and check its addition
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_BADDEFERRABILITY);
CLEANUP:
SAFE_FREE(pwszConstraintText);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_Deferrability::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCCreateTableWithConstraints_NoConstraint)
//*-----------------------------------------------------------------------
//| Test Case: TCCreateTableWithConstraints_NoConstraint - Testcase for ITableDefinitionWithConstraints::AddConstraint used with deferrability setting
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCreateTableWithConstraints_NoConstraint::Init()
{
ITableDefinitionWithConstraints *pITableDefinitionWithConstraints = NULL;
if(TCCreateTable::Init())
{
// check for ITableDefinition
if (!(m_hr=VerifyInterface(m_pIOpenRowset, IID_ITableDefinitionWithConstraints, SESSION_INTERFACE, (IUnknown**)&pITableDefinitionWithConstraints)))
{
odtLog << "ITableDefinitionWithConstraints is not supported\n";
return TEST_SKIPPED;
}
SAFE_RELEASE(pITableDefinitionWithConstraints);
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------
//
// @member Create the table using ITableDefinition::CreateTable and
// check its creation
//---------------------------------------------------------------------
HRESULT TCCreateTableWithConstraints_NoConstraint::CreateAndCheckTable(
ITableDefinition *pITableDefinition, // [in] pointer to the ITableDefinition interface to be used
IUnknown *pUnkOuter, // [in] pointer to controlling unknown
DBID *pTableID, // [in] pointer to the input table ID
DBORDINAL cColumnDescs, // [in] the number of columns to be created
DBCOLUMNDESC *rgColumnDescs, // [in/out] array of columns to be created
REFIID riid, // [in] rowset interface to be returned
ULONG cPropertySets, // [in] number of roset property sets asked
DBPROPSET *rgPropertySets, // [in/out] array of rowset property sets
DBID **ppTableID, // [out] returned table ID
IUnknown **ppRowset // [out] pointer to outer interface
)
{
HRESULT hr = E_FAIL;
ITableDefinitionWithConstraints *pITDWC = NULL;
TESTC(NULL != pITableDefinition);
TESTC(VerifyInterface(pITableDefinition, IID_ITableDefinitionWithConstraints,
SESSION_INTERFACE, (IUnknown**)&pITDWC));
hr = CreateAndCheckTableWithConstraints(pITDWC, pUnkOuter, pTableID,
cColumnDescs, rgColumnDescs, 0, NULL,
riid, cPropertySets, rgPropertySets,
ppTableID, ppRowset);
CLEANUP:
SAFE_RELEASE(pITDWC);
return hr;
} //TCCreateTableWithConstraints_NoConstraint::CreateAndCheckTable
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCCreateTableWithConstraints_NoConstraint::Terminate()
{
return(TCCreateTable::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCCreateTableWithConstraints)
//*-----------------------------------------------------------------------
//| Test Case: TCCreateTableWithConstraints - Testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints when constraints are set
//| Created: 7/29/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCreateTableWithConstraints::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Create a table and multiple constraint of various types
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_1()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Table with a unique constraint (on a single column)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_2()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Table with a unique constraint (on multiple columns)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_3()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[0].dbcid);
consUnique.AddColumn(&rgColumnDesc[3].dbcid);
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Table with a primary key constraint (on a single column)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_4()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CPrimaryKeyCons consPK;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a primary key constraint on the second column
consPK.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consPK,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Table with a primary key constraint (on multiple columns)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_5()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CPrimaryKeyCons consPK;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a primary key constraint on the second column
consPK.AddColumn(&rgColumnDesc[1].dbcid);
consPK.AddColumn(&rgColumnDesc[3].dbcid);
consPK.AddColumn(&rgColumnDesc[2].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consPK,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Table with a foreign key constraint (single column)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_6()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBORDINAL indexCol = 2;
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CForeignKeyCons consFK(NULL, m_SupportedMatchType);
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, indexCol, (DBDEFERRABILITY)0), S_OK);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(indexCol, col), S_OK);
consFK.AddColumn(col.GetColID());
consFK.AddForeignKeyColumn(&rgColumnDesc[indexCol-1].dbcid);
consFK.SetReferencedTableID(&ReferencedTable.GetTableID());
TESTC_(consFK.MakeConstraintName(), S_OK);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consFK,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Table with foreign key constraint defined on multiple keys
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_7()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBORDINAL rgColumns[] = {2, 1};
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CForeignKeyCons consFK(NULL, m_SupportedMatchType);
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, NUMELEM(rgColumns), rgColumns, (DBDEFERRABILITY)0), S_OK);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(rgColumns[0], col), S_OK);
consFK.AddColumn(col.GetColID());
TESTC_(ReferencedTable.GetColInfo(rgColumns[1], col), S_OK);
consFK.AddColumn(col.GetColID());
consFK.AddForeignKeyColumn(&rgColumnDesc[rgColumns[0]-1].dbcid);
consFK.AddForeignKeyColumn(&rgColumnDesc[rgColumns[1]-1].dbcid);
consFK.SetReferencedTableID(&ReferencedTable.GetTableID());
TESTC_(consFK.MakeConstraintName(), S_OK);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consFK,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Table with a simple check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_8()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CCheckCons cons;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NOT NULL";
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(rgColumnDesc[0].dbcid.uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, rgColumnDesc[0].dbcid.uName.pwszName);
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, cons,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
SAFE_FREE(pwszConstraintText);
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Table with multiple unique constraints defined
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_9()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CUniqueCons consUnique1;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
consUnique.MakeConstraintName();
// set second unique constraints on the firstcolumn
consUnique1.AddColumn(&rgColumnDesc[0].dbcid);
consUnique1.MakeConstraintName();
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consUnique1);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Table with unique constraint and foreign key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_10()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
consUnique.MakeConstraintName();
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.MakeConstraintName();
// add all constraint to the array
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consUnique);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Table with primary key and check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_11()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NOT NULL";
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
SetProperty(&rgColumnDesc[1].rgPropertySets, &rgColumnDesc[1].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// set a primary key constraint on the first column
consPK.AddColumn(&rgColumnDesc[0].dbcid);
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[1].dbcid.eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(rgColumnDesc[1].dbcid.uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, rgColumnDesc[1].dbcid.uName.pwszName);
wcscat(pwszConstraintText, wszText);
consCheck.SetConstraintText(pwszConstraintText);
// add all constraint to the array
ConsDescArray.AddConsDesc(consPK);
ConsDescArray.AddConsDesc(consCheck);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
SAFE_FREE(pwszConstraintText);
CHECK(DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Deferrable, immediate constraints
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_12()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
CCheckCons consCheck;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
DBORDINAL rgReferencedCol[] = {1};
CCol col;
HRESULT hr;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
consUnique.SetDeferrability(DBDEFERRABILITY_DEFERRABLE);
// try to create a table with a deferrable unique constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consUnique, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
consPrimaryKey.SetDeferrability(DBDEFERRABILITY_DEFERRABLE);
// try to create a table with a deferrable primary key constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consPrimaryKey, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.SetDeferrability(DBDEFERRABILITY_DEFERRABLE);
// try to create a table with a deferrable foreign key constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consForeignKey, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[4].dbcid.eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(rgColumnDesc[4].dbcid.uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, rgColumnDesc[4].dbcid.uName.pwszName);
wcscat(pwszConstraintText, wszText);
consCheck.SetConstraintText(pwszConstraintText);
consCheck.SetDeferrability(DBDEFERRABILITY_DEFERRABLE);
// try to create a table with a deferrable check constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consCheck, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
CLEANUP:
SAFE_FREE(pwszConstraintText);
DropTableAndCheck(&TableID);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Deferred constraints
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_13()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
CCheckCons consCheck;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NULL";
DBORDINAL rgReferencedCol[] = {1};
CCol col;
HRESULT hr;
CTable Table(m_pITableDefinition, (LPWSTR)gwszModuleName);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
consUnique.SetDeferrability(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED);
// try to create a table with a deferrable unique constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consUnique, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// try to insert a duplicate value in the second column and check it is possible
Table.SetTableID(TableID);
if (CHECK(Table.GetTableColumnInfo(&TableID), S_OK))
{
CHECK(Table.Insert(1), S_OK);
CHECK(Table.Insert(1), S_OK);
}
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
consPrimaryKey.SetDeferrability(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED);
// try to create a table with a deferrable primary key constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consPrimaryKey, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// try to insert a duplicate value in the primary key column and check it is possible
Table.SetTableID(TableID);
if (CHECK(Table.GetTableColumnInfo(&TableID), S_OK))
{
CHECK(Table.Insert(1), S_OK);
CHECK(Table.Insert(1), S_OK);
}
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.SetDeferrability(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED);
// try to create a table with a deferrable foreign key constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consForeignKey, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// try to insert a row base table (referenced table is empty)
Table.SetTableID(TableID);
if (CHECK(Table.GetTableColumnInfo(&TableID), S_OK))
{
CHECK(Table.Insert(7), S_OK);
CHECK(Table.Insert(5), S_OK);
}
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[4].dbcid.eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(rgColumnDesc[4].dbcid.uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, rgColumnDesc[4].dbcid.uName.pwszName);
wcscat(pwszConstraintText, wszText);
consCheck.SetConstraintText(pwszConstraintText);
consCheck.SetDeferrability(DBDEFERRABILITY_DEFERRABLE | DBDEFERRABILITY_DEFERRED);
// try to create a table with a deferrable check constraint
hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consCheck, IID_IRowset, 0, NULL, NULL, NULL);
if (S_OK == hr)
{
// try to insert a not null value in the checked column
Table.SetTableID(TableID);
if (CHECK(Table.GetTableColumnInfo(&TableID), S_OK))
{
CHECK(Table.Insert(1), S_OK);
CHECK(Table.Insert(10), S_OK);
}
// drop the table
CHECK(DropTableAndCheck(&TableID, m_pITableDefinition), S_OK);
}
else
{
CHECK(hr, DB_E_BADDEFERRABILITY);
}
CLEANUP:
SAFE_FREE(pwszConstraintText);
DropTableAndCheck(&TableID);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Abort retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_14()
{
CCreateTableWithConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Abort non retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_15()
{
CCreateTableWithConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Commit retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_16()
{
CCreateTableWithConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Commit non retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints::Variation_17()
{
CCreateTableWithConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCCreateTableWithConstraints::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCCreateTableWithConstraints_Boundary)
//*-----------------------------------------------------------------------
//| Test Case: TCCreateTableWithConstraints_Boundary - Boundary and NULL testcase for ITableDefinitionWithConstraints::CreateTableWithConstraints
//| Created: 9/3/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCreateTableWithConstraints_Boundary::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc 0 < cConstraintDescs and NULL == rgConstraintDescs => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_1()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
3, NULL,
IID_IRowset, 0, NULL, NULL, NULL), E_INVALIDARG);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc 0 == cConstraintDescs and NULL != rgConstraintDescs => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_2()
{
TBEGIN
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons cons;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
cons.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
0, cons,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(this->DropTableAndCheck(&TableID), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL ppTableID is not NULL => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_3()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(pTableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Bad DBKIND of a constraint ID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_4()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
ReleaseDBID(((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID, FALSE);
((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID->eKind = 0xb2;
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTID);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc NULL pConstraintID in a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_5()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
ReleaseDBID(((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID, TRUE);
((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID = NULL;
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(pTableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc NULL column list in a constraint, column size is not 0 => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_6()
{
// this tests rgColumnList for PK, FK and unique constraints
// as well as rgForeignKeyColumnList for FK
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CUniqueCons cons;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBCONSTRAINTDESC *pConsDesc;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
cons.AddColumn(&rgColumnDesc[0].dbcid);
pConsDesc = consUnique;
pConsDesc->cColumns = 2;
pConsDesc->rgColumnList = NULL;
ConsDescArray.AddConsDesc(cons);
ConsDescArray.AddConsDesc(consUnique);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG);
// set a primary key on the first column of the table
pConsDesc = consPrimaryKey;
pConsDesc->cColumns = 5;
pConsDesc->rgColumnList = NULL;
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
pConsDesc = consForeignKey;
pConsDesc->cColumns = 1;
pConsDesc->rgColumnList = NULL;
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG);
// the same check for foreign key column list
consForeignKey.ReleaseForeignKeyColumnList();
pConsDesc->cForeignKeyColumns = 1;
pConsDesc->cColumns = 0;
consForeignKey.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Empty list of columns for a unique, primay key or foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_7()
{
// this tests rgColumnList for PK, FK and unique constraints
// as well as rgForeignKeyColumnList for FK
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CUniqueCons cons;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
cons.AddColumn(&rgColumnDesc[0].dbcid);
ConsDescArray.AddConsDesc(cons);
ConsDescArray.AddConsDesc(consUnique);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
// set a primary key on the first column of the table
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
TEST2C_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG, DB_E_BADCONSTRAINTFORM);
// the same check for foreign key column list
consForeignKey.ReleaseForeignKeyColumnList();
consForeignKey.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc Non empty list of columns for a check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_8()
{
// this tests the case when rgColumnList or rgForeignKeyColumnList
// are not empty in a check constraint
TBEGIN
CCheckCons consCheck;
DBCONSTRAINTDESC *pcons = consCheck;
WCHAR *pwszConstraintText = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
WCHAR wszText[] = L" IS NOT NULL";
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
// create the text of the constraint
SAFE_FREE(pwszConstraintText);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(rgColumnDesc[0].dbcid.uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, rgColumnDesc[0].dbcid.uName.pwszName);
wcscat(pwszConstraintText, wszText);
consCheck.SetConstraintText(pwszConstraintText);
// not empty rgColumnList
pcons->cColumns = 1;
pcons->rgColumnList = &rgColumnDesc[0].dbcid;
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consCheck,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
// not empty rgForeignKeyColumnList
pcons->cColumns = 0;
pcons->rgColumnList = NULL;
pcons->cForeignKeyColumns = 1;
pcons->rgForeignKeyColumnList = &rgColumnDesc[0].dbcid;
TEST2C_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consCheck,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM, E_INVALIDARG);
// not empty rgColumnList and rgForeignKeyColumnList
pcons->cColumns = 1;
pcons->rgColumnList = &rgColumnDesc[0].dbcid;
pcons->cForeignKeyColumns = 1;
pcons->rgForeignKeyColumnList = &rgColumnDesc[0].dbcid;
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consCheck,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
CLEANUP:
pcons->cColumns = 0;
pcons->rgColumnList = NULL;
pcons->cForeignKeyColumns = 0;
pcons->rgForeignKeyColumnList = NULL;
SAFE_FREE(pwszConstraintText);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc Non empty list of foreign keys for a constraint that is not foreign key
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_9()
{
TBEGIN
CForeignKeyCons consFK;
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
const DBORDINAL cColumns = 2;
DBID rgColumnList[cColumns];
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
rgColumnList[0].eKind = DBKIND_NAME;
rgColumnList[0].uName.pwszName = (LPWSTR)0x01234567;
rgColumnList[1].eKind = 0xfe;
rgColumnList[1].uName.pwszName = (LPWSTR)0x01234567;
// set up the unique constraint
consUnique.AddColumn(&rgColumnDesc[0].dbcid);
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consUnique)->rgForeignKeyColumnList = rgColumnList;
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consUnique)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consUnique)->rgForeignKeyColumnList = NULL;
// set up the primary key constraint
consPK.AddColumn(&rgColumnDesc[0].dbcid);
consPK.AddColumn(&rgColumnDesc[1].dbcid);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consPK)->rgForeignKeyColumnList = rgColumnList;
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPK,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consPK)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consPK)->rgForeignKeyColumnList = NULL;
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = cColumns;
((DBCONSTRAINTDESC*)consCheck)->rgForeignKeyColumnList = rgColumnList;
TEST2C_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consCheck,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG, DB_E_BADCONSTRAINTFORM);
CLEANUP:
((DBCONSTRAINTDESC*)consCheck)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consCheck)->rgForeignKeyColumnList = NULL;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc 0 < cForeignKeyColumns and NULL == rgForeignKeyColumnList => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_10()
{
// this tests rgColumnList for PK, FK and unique constraints
// as well as rgForeignKeyColumnList for FK
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons cons;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a simple foreign key constraint
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.AddColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.ReleaseForeignKeyColumnList();
((DBCONSTRAINTDESC*)consForeignKey)->cForeignKeyColumns = 1;
consForeignKey.AddColumn(&rgColumnDesc[0].dbcid);
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), E_INVALIDARG);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc Constraint is not foreign key and pReferencedTableID is not NULL
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_11()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CUniqueCons consUnique;
CPrimaryKeyCons consPK;
CCheckCons consCheck;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the unique constraint
consUnique.AddColumn(&rgColumnDesc[0].dbcid);
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
DBID* pTempDBID = NULL;
DuplicateDBID(ReferencedTable.GetTableIDRef(), pTempDBID);
((DBCONSTRAINTDESC*)consUnique)->pReferencedTableID = pTempDBID;
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consUnique)->pReferencedTableID = NULL;
// set up the primary key constraint
consPK.AddColumn(&rgColumnDesc[0].dbcid);
consPK.AddColumn(&rgColumnDesc[1].dbcid);
DuplicateDBID(ReferencedTable.GetTableIDRef(), pTempDBID);
((DBCONSTRAINTDESC*)consPK)->pReferencedTableID = pTempDBID;
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPK,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consPK)->pReferencedTableID = NULL;
// set up the check constraint
consCheck.SetConstraintText(L"TRUE != FALSE");
DuplicateDBID(ReferencedTable.GetTableIDRef(), pTempDBID);
((DBCONSTRAINTDESC*)consCheck)->pReferencedTableID = pTempDBID;
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consCheck,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
((DBCONSTRAINTDESC*)consCheck)->pReferencedTableID = NULL;
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc NULL pReferencedTableID for a foreign key constraint (with and without cForeignKeyColumns being 0)
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_12()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID(NULL);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
CHECK(consForeignKey.MakeConstraintName(), S_OK);
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTFORM);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc NULL referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_13()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
DBID ReferencedTableID;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = NULL;
consForeignKey.SetReferencedTableID(&ReferencedTableID);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc DB_NULLID *pReferencedTableID for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_14()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID((DBID*)&DB_NULLID);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Empty string referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_15()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
DBID ReferencedTableID;
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = L"";
consForeignKey.SetReferencedTableID(&ReferencedTableID);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Maximum length referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_16()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
WCHAR *pwszTableName = NULL;
CUniqueCons cons;
// create support for foreign key constraint
ReferencedTable.MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, ReferencedTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0, pwszTableName), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
CHECK(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(pTableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
SAFE_FREE(pwszTableName);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Referenced table name longer than allowed for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_17()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
DBID ReferencedTableID;
// create support for foreign key constraint
ReferencedTable.MakeTableName(NULL);
ReferencedTableID.eKind = DBKIND_NAME;
ReferencedTableID.uName.pwszName = BuildValidName(m_cMaxTableName+1, ReferencedTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID(&ReferencedTableID);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
ReleaseDBID(&ReferencedTableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Illegal characters in the referenced table name for a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_18()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
CCol col;
DBID ReferencedTableID;
size_t m, n;
// create support for foreign key constraint
ReferencedTable.MakeTableName(NULL);
ReferencedTableID.eKind = DBKIND_NAME;
m = min(m_cMaxTableName, n=5+wcslen(ReferencedTable.GetTableName()));
ReferencedTableID.uName.pwszName = BuildInvalidName(m, ReferencedTable.GetTableName(), m_pwszInvalidTableChars);
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID(&ReferencedTableID);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
ReleaseDBID(&ReferencedTableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Bad constraint type
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_19()
{
TBEGIN
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
DBCONSTRAINTDESC ConsDesc;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// set up the check constraint
memset(&ConsDesc, 0, sizeof(DBCONSTRAINTDESC));
ConsDesc.ConstraintType = 0x4b;
TESTC_(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, &ConsDesc,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_BADCONSTRAINTTYPE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Inexistent referenced table
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_20()
{
TBEGIN
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
DBID *pTableID = NULL;
// create support for foreign key constraint
ReferencedTable.MakeTableName(NULL);
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind
&& rgColumnDesc[0].dbcid.uName.pwszName);
// set up the check constraint
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
consForeignKey.AddColumn(&rgColumnDesc[0].dbcid);
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
CHECK(CreateAndCheckTableWithConstraints(
m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL,
&pTableID, NULL), DB_E_NOTABLE);
CLEANUP:
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
ReleaseDBID(pTableID, TRUE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Empty string for a column name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_21()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBID colid;
colid.eKind = DBKIND_NAME;
colid.uName.pwszName = L"";
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&colid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&colid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&colid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc Maximum length column name in a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_22()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
WCHAR *pwszColName = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// build the column name
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind);
pwszColName = rgColumnDesc[0].dbcid.uName.pwszName;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszColName);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[0].dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), S_OK);
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID, TRUE);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), S_OK);
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID, TRUE);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), S_OK);
CHECK(DropTableAndCheck(pTableID), S_OK);
ReleaseDBID(pTableID, TRUE);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
SAFE_FREE(pwszColName);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Invalid DBKIND for a column DBID of a constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_23()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBID dbcid;
dbcid.eKind = 0x3c;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
((DBCONSTRAINTDESC*)consUnique)->cColumns = 1;
((DBCONSTRAINTDESC*)consUnique)->rgColumnList = &dbcid;
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
((DBCONSTRAINTDESC*)consPrimaryKey)->cColumns = 1;
((DBCONSTRAINTDESC*)consPrimaryKey)->rgColumnList = &dbcid;
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
((DBCONSTRAINTDESC*)consForeignKey)->cForeignKeyColumns = 1;
((DBCONSTRAINTDESC*)consForeignKey)->rgForeignKeyColumnList = &dbcid;
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
((DBCONSTRAINTDESC*)consUnique)->cColumns = 0;
((DBCONSTRAINTDESC*)consUnique)->rgColumnList = NULL;
((DBCONSTRAINTDESC*)consPrimaryKey)->cColumns = 0;
((DBCONSTRAINTDESC*)consPrimaryKey)->rgColumnList = NULL;
((DBCONSTRAINTDESC*)consForeignKey)->cForeignKeyColumns = 0;
((DBCONSTRAINTDESC*)consForeignKey)->rgForeignKeyColumnList = NULL;
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Column ID is DB_NULLID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_24()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
WCHAR *pwszColName = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// build the column name
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind);
pwszColName = rgColumnDesc[0].dbcid.uName.pwszName;
rgColumnDesc[0].dbcid.uName.pwszName = BuildValidName(m_cMaxColName, pwszColName);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on column DB_NULLID
consUnique.AddColumn((DBID*)&DB_NULLID);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on DB_NULLID
consPrimaryKey.AddColumn((DBID*)&DB_NULLID);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn((DBID*)&DB_NULLID);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
SAFE_FREE(pwszColName);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Inexistent column => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_25()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc-1;
TESTC_PROVIDER(1 < m_cColumnDesc);
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[cColumnDesc].dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[cColumnDesc].dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[cColumnDesc].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
cColumnDesc = m_cColumnDesc;
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc NULL column name => DB_E_NOCOLUMN
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_26()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBID dbcid;
dbcid.eKind = DBKIND_NAME;
dbcid.uName.pwszName = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Column name exceeds maximum length name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_27()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBID dbcid;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind);
dbcid.eKind = DBKIND_NAME;
dbcid.uName.pwszName = BuildValidName(m_cMaxColName+1, rgColumnDesc[0].dbcid.uName.pwszName);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc Invalid column name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_28()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID *pTableID = NULL;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DBID dbcid;
size_t m, n;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
TESTC_PROVIDER(DBKIND_NAME == rgColumnDesc[0].dbcid.eKind);
m = min(m_cMaxColName, n=5+wcslen(rgColumnDesc[0].dbcid.uName.pwszName));
dbcid.eKind = DBKIND_NAME;
dbcid.uName.pwszName = BuildInvalidName(m, rgColumnDesc[0].dbcid.uName.pwszName, m_pwszInvalidColChars);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consUnique,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&dbcid);
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consPrimaryKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
CHECK(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, NULL,
cColumnDesc, rgColumnDesc,
1, consForeignKey,
IID_IRowset, 0, NULL, &pTableID, NULL), DB_E_NOCOLUMN);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Existent table name => DB_E_DUPLICATETABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_29()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_DUPLICATETABLEID);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Same constraint name in 2 constraints => DB_E_DUPLICATECONSTRAINTID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_30()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
consPrimaryKey.SetConstraintName(consUnique.GetConstraintID()->uName.pwszName);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_DUPLICATECONSTRAINTID);
CLEANUP:
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc NULL pConstraintID in 2 constraints => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_31()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
ReleaseDBID(((DBCONSTRAINTDESC*)consUnique)->pConstraintID, TRUE);
((DBCONSTRAINTDESC*)consUnique)->pConstraintID = NULL;
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
ReleaseDBID(((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID);
((DBCONSTRAINTDESC*)consPrimaryKey)->pConstraintID = NULL;
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(32)
//*-----------------------------------------------------------------------
// @mfunc Try to create table with constraints, but table already exists => DB_E_DUPLICATEDTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Boundary::Variation_32()
{
TBEGIN
HRESULT hr;
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
TESTC_(hr = CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), DB_E_DUPLICATETABLEID);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCCreateTableWithConstraints_Boundary::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCDropConstraint)
//*-----------------------------------------------------------------------
//| Test Case: TCDropConstraint - Testcase for ITableDefinitionWithConstraints::DropConstraint
//| Created: 8/9/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropConstraint::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc pTableID is NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_1()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, NULL, cons), E_INVALIDARG);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc pTableID.uName.pwszName is NULL => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_2()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
DBID TableID;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// alloc memory for column array
pConsDesc->cColumns = 1;
SAFE_ALLOC(pConsDesc->rgColumnList, DBID, pConsDesc->cColumns);
memset(pConsDesc->rgColumnList, 0, sizeof(pConsDesc->rgColumnList));
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
DuplicateDBID(*col.GetColID(), pConsDesc->rgColumnList);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = NULL;
TEST2C_(DropConstraintAndCheck(m_pITDWC, &TableID, pConsDesc->pConstraintID), DB_E_BADTABLEID, DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Table name is empty => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_3()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
DBID TableID;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// alloc memory for column array
pConsDesc->cColumns = 1;
SAFE_ALLOC(pConsDesc->rgColumnList, DBID, pConsDesc->cColumns);
memset(pConsDesc->rgColumnList, 0, sizeof(pConsDesc->rgColumnList));
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
DuplicateDBID(*col.GetColID(), pConsDesc->rgColumnList);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = L"";
TEST2C_(DropConstraintAndCheck(m_pITDWC, &TableID, pConsDesc->pConstraintID),
DB_E_BADTABLEID, DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Table name is not the one on which the column was created
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_4()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable Table2(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
HRESULT hr;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
TESTC_(Table2.CreateTable(0, 0), S_OK);
Table2.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table2.GetTableName());
// alloc memory for column array
pConsDesc->cColumns = 1;
SAFE_ALLOC(pConsDesc->rgColumnList, DBID, pConsDesc->cColumns);
memset(pConsDesc->rgColumnList, 0, sizeof(pConsDesc->rgColumnList));
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
DuplicateDBID(*col.GetColID(), pConsDesc->rgColumnList);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TEST2C_(hr = DropConstraintAndCheck(m_pITDWC, &Table2.GetTableID(),
pConsDesc->pConstraintID), S_OK, E_FAIL);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), pConsDesc->pConstraintID),
(S_OK == hr)? DB_E_BADTABLEID: S_OK);
CLEANUP:
Table.DropTable();
Table2.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc Inexistent table name => DB_E_NOTABLE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_5()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CTable Table2(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
DBCONSTRAINTDESC *pConsDesc = (DBCONSTRAINTDESC*)cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// alloc memory for column array
pConsDesc->cColumns = 1;
SAFE_ALLOC(pConsDesc->rgColumnList, DBID, pConsDesc->cColumns);
memset(pConsDesc->rgColumnList, 0, sizeof(pConsDesc->rgColumnList));
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
DuplicateDBID(*col.GetColID(), pConsDesc->rgColumnList);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(Table2.MakeTableName(NULL), S_OK);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table2.GetTableID(), pConsDesc->pConstraintID), DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(6)
//*-----------------------------------------------------------------------
// @mfunc Maximum table name => S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_6()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
WCHAR *pwszTableName = NULL;
// create the base table with maximum name length
Table.MakeTableName(NULL);
pwszTableName = BuildValidName(m_cMaxTableName, Table.GetTableName());
TESTC_(Table.CreateTable(0, 0, pwszTableName), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(),
cons.GetConstraintID()), S_OK);
CLEANUP:
Table.DropTable();
SAFE_FREE(pwszTableName);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(7)
//*-----------------------------------------------------------------------
// @mfunc Invalid characters in table's name => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_7()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
size_t m, n;
DBID TableID;
// create the base table
TESTC_(Table.CreateTable(0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// set an invalid table name
m = min(m_cMaxColName, n=5+wcslen(Table.GetTableName()));
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = BuildInvalidName(m, Table.GetTableName(), m_pwszInvalidColChars);
// drop the constraint
TEST2C_(DropConstraintAndCheck(m_pITDWC, &TableID, cons.GetConstraintID()), DB_E_BADTABLEID, DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
ReleaseDBID(&TableID, FALSE);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(8)
//*-----------------------------------------------------------------------
// @mfunc pConstraintID is NUL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_8()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint and recreate it
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), NULL), E_INVALIDARG);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(9)
//*-----------------------------------------------------------------------
// @mfunc *pConstraintID is DB_NULLID => DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_9()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
cons.SetConstraintID((DBID*)&DB_NULLID);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(10)
//*-----------------------------------------------------------------------
// @mfunc Invalid DBKIND in the constraint name => DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_10()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
ReleaseDBID(((DBCONSTRAINTDESC*)cons)->pConstraintID, FALSE);
((DBCONSTRAINTDESC*)cons)->pConstraintID->eKind = 0xa0;
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
((DBCONSTRAINTDESC*)cons)->pConstraintID->eKind = DBKIND_NAME;
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(11)
//*-----------------------------------------------------------------------
// @mfunc NULL constraint name => DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_11()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
cons.SetConstraintName(NULL);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(12)
//*-----------------------------------------------------------------------
// @mfunc Constraint name is empty string => DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_12()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
cons.SetConstraintName(L"");
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(13)
//*-----------------------------------------------------------------------
// @mfunc Inexistent constraint name => DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_13()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
cons.MakeConstraintName();
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(14)
//*-----------------------------------------------------------------------
// @mfunc Drop a constraint twice
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_14()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose a column and create a unique constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), DB_E_NOCONSTRAINT);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(15)
//*-----------------------------------------------------------------------
// @mfunc Drop a unique constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_15()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose a column and create a unique constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(16)
//*-----------------------------------------------------------------------
// @mfunc Drop a primary key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_16()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
CCol col;
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// choose a column and create a primary key constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(17)
//*-----------------------------------------------------------------------
// @mfunc Drop a foreign key constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_17()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CCol col;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
// choose 1 column and create a unique constraint on them
TESTC_(BaseTable.GetColInfo(1, col), S_OK);
cons.AddForeignKeyColumn(col.GetColID());
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
CLEANUP:
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(18)
//*-----------------------------------------------------------------------
// @mfunc Drop a check constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_18()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NOT NULL";
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// choose a column and create a primary key constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == col.GetColID()->eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColID()->uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColID()->uName.pwszName);
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
CLEANUP:
Table.DropTable();
SAFE_FREE(pwszConstraintText);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(19)
//*-----------------------------------------------------------------------
// @mfunc Create several constraints, drop a single constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_19()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBID TableID;
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray;
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
DBORDINAL rgReferencedCol[] = {1};
CCol col;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
m_pTable->MakeTableName(NULL);
TableID.eKind = DBKIND_NAME;
TableID.uName.pwszName = m_pTable->GetTableName();
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray.AddConsDesc(consUnique);
ConsDescArray.AddConsDesc(consForeignKey);
ConsDescArray.AddConsDesc(consPrimaryKey);
TESTC_(CreateAndCheckTableWithConstraints(m_pITDWC, NULL, &TableID, cColumnDesc, rgColumnDesc,
ConsDescArray, ConsDescArray,
IID_IRowset, 0, NULL, NULL, NULL), S_OK);
CHECK(DropConstraintAndCheck(m_pITDWC, &TableID, consForeignKey), S_OK);
CHECK(DropConstraintAndCheck(m_pITDWC, &TableID, consUnique), S_OK);
CHECK(DropConstraintAndCheck(m_pITDWC, &TableID, consPrimaryKey), S_OK);
CLEANUP:
CHECK(DropTableAndCheck(&TableID), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(20)
//*-----------------------------------------------------------------------
// @mfunc Drop a unique constraint in the referenced table, after the foreign key constraint was added
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_20()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CUniqueCons consUnique;
CUniqueCons consUnique1;
CCol col;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
consUnique.SetConstraint(&ReferencedTable, 1);
TESTC_(AddConstraintAndCheck(m_pITDWC, &ReferencedTable.GetTableID(), consUnique), S_OK);
consUnique1.SetConstraint(&ReferencedTable, 2);
TESTC_(AddConstraintAndCheck(m_pITDWC, &ReferencedTable.GetTableID(), consUnique1), S_OK);
// choose 1 column and create a unique constraint on them
TESTC_(BaseTable.GetColInfo(1, col), S_OK);
cons.AddForeignKeyColumn(col.GetColID());
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
// drop the unique constraints on the referenced table
CHECK(DropConstraintAndCheck(m_pITDWC, &ReferencedTable.GetTableID(), consUnique),
DB_E_DROPRESTRICTED);
CHECK(DropConstraintAndCheck(m_pITDWC, &ReferencedTable.GetTableID(), consUnique1),
S_OK);
// drop the foreign key constraint on the base table
CHECK(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
// drop the unique constraint on the referenced table
CHECK(DropConstraintAndCheck(m_pITDWC, &ReferencedTable.GetTableID(), consUnique),
S_OK);
CLEANUP:
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(21)
//*-----------------------------------------------------------------------
// @mfunc Try to drop a unique constraint while a rowset is opened on the table => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_21()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
IRowsetChange *pIRowsetChange = NULL;
HRESULT hr;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose a column and create a unique constraint on it
TESTC_(Table.GetColInfo(3, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// open a rowset on the table
CHECK(Table.Insert(7), S_OK);
CHECK(Table.Insert(7), DB_E_INTEGRITYVIOLATION);
TESTC_(hr = m_pIOpenRowset->OpenRowset(NULL, &Table.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK);
// drop the constraint
TEST2C_(hr = DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons),
S_OK, DB_E_TABLEINUSE);
if (S_OK == hr)
{
odtLog << "Constraint was dropped\n";
CHECK(Table.Insert(7), S_OK);
}
else
CHECK(Table.Insert(7), DB_E_INTEGRITYVIOLATION);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(22)
//*-----------------------------------------------------------------------
// @mfunc *pTableID is DB_NULLID => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_22()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TEST2C_(DropConstraintAndCheck(m_pITDWC, (DBID*)&DB_NULLID, cons), DB_E_BADTABLEID, DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(23)
//*-----------------------------------------------------------------------
// @mfunc Invalid DBKIND in pTableID => DB_E_BADTABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_23()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
DBID TableID;
TESTC_(Table.CreateTable(0, 0), S_OK);
Table.AddInfoFromColumnsSchemaRowset(m_pITDWC, Table.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
// drop the constraint
TableID.eKind = 0x44;
TEST2C_(DropConstraintAndCheck(m_pITDWC, &TableID, cons), DB_E_BADTABLEID, DB_E_NOTABLE);
CLEANUP:
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(24)
//*-----------------------------------------------------------------------
// @mfunc Try to drop a check constraint while a rowset is opened on the table => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_24()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CCheckCons cons;
CCol col;
WCHAR *pwszConstraintText = NULL;
WCHAR wszText[] = L" IS NOT NULL";
IRowsetChange *pIRowsetChange = NULL;
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// choose a column and create a primary key constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
// build constraint text
TESTC_PROVIDER(DBKIND_NAME == col.GetColID()->eKind);
SAFE_ALLOC(pwszConstraintText, WCHAR, 1 + wcslen(col.GetColID()->uName.pwszName) + wcslen(wszText));
wcscpy(pwszConstraintText, col.GetColID()->uName.pwszName);
wcscat(pwszConstraintText, wszText);
cons.SetConstraintText(pwszConstraintText);
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(m_pIOpenRowset->OpenRowset(NULL, &Table.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK);
// drop the constraint
TEST2C_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK, DB_E_TABLEINUSE);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
Table.DropTable();
SAFE_FREE(pwszConstraintText);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(25)
//*-----------------------------------------------------------------------
// @mfunc Try to drop a pk constraint while a rowset is opened on the table => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_25()
{
TBEGIN
CTable Table(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
CPrimaryKeyCons cons;
CCol col;
IRowsetChange *pIRowsetChange = NULL;
TESTC_(CreateTableWithNoNullableColumns(&Table, 0), S_OK);
// choose a column and create a primary key constraint on it
TESTC_(Table.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK);
TESTC_(m_pIOpenRowset->OpenRowset(NULL, &Table.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK);
// drop the constraint
TEST2C_(DropConstraintAndCheck(m_pITDWC, &Table.GetTableID(), cons), S_OK, DB_E_TABLEINUSE);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
Table.DropTable();
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(26)
//*-----------------------------------------------------------------------
// @mfunc Try to drop a fk constraint while a rowset is opened on the table => DB_E_TABLEINUSE
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_26()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CForeignKeyCons cons(NULL, m_SupportedMatchType);
CCol col;
IRowsetChange *pIRowsetChange = NULL;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
// choose 1 column and create a unique constraint on them
TESTC_(BaseTable.GetColInfo(1, col), S_OK);
cons.AddForeignKeyColumn(col.GetColID());
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
cons.AddColumn(col.GetColID());
cons.SetReferencedTableID(&ReferencedTable.GetTableID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
TESTC_(m_pIOpenRowset->OpenRowset(NULL, &BaseTable.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK);
// drop the constraint
TEST2C_(DropConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK, DB_E_TABLEINUSE);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
CHECK(BaseTable.DropTable(), S_OK);
CHECK(ReferencedTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(27)
//*-----------------------------------------------------------------------
// @mfunc Both pTableID and pConstraintID are NULL => E_INVALIDARG
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_27()
{
TBEGIN
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
CUniqueCons cons;
CCol col;
IRowsetChange *pIRowsetChange = NULL;
TESTC_(BaseTable.CreateTable(0, 0), S_OK);
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
// choose 1 column and create a unique constraint on them
TESTC_(BaseTable.GetColInfo(1, col), S_OK);
// Add constraint
cons.AddColumn(col.GetColID());
TESTC_(AddConstraintAndCheck(m_pITDWC, &BaseTable.GetTableID(), cons), S_OK);
TESTC_(m_pIOpenRowset->OpenRowset(NULL, &BaseTable.GetTableID(), NULL,
IID_IRowsetChange, 0, NULL, (IUnknown**)&pIRowsetChange), S_OK);
// drop the constraint
TESTC_(DropConstraintAndCheck(m_pITDWC, NULL, NULL), E_INVALIDARG);
CLEANUP:
SAFE_RELEASE(pIRowsetChange);
CHECK(BaseTable.DropTable(), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(28)
//*-----------------------------------------------------------------------
// @mfunc Abort retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_28()
{
CDropConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(29)
//*-----------------------------------------------------------------------
// @mfunc Abort non retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_29()
{
CDropConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
TRUE, // Abort
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(30)
//*-----------------------------------------------------------------------
// @mfunc Commit retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_30()
{
CDropConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
TRUE // Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(31)
//*-----------------------------------------------------------------------
// @mfunc Commit non retain
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint::Variation_31()
{
CDropConsTxnAdapter TxnAdapter(this);
CTransactionLocal TxnLocal;
return TxnLocal.DoTransactionTest(m_pITDWC, &TxnAdapter,
TRUE, // DDL
FALSE, // Commit
FALSE // Non Retaining
);
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCDropConstraint::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCAddConstraint_Multithreading)
//*-----------------------------------------------------------------------
//| Test Case: TCAddConstraint_Multithreading - Testcase for ITableDefinitionWithConstraints::AddConstraint used in multithreaded calls
//| Created: 9/14/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCAddConstraint_Multithreading::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------
//
// @cmember Thread funtion for TCAddConstraint_Multithreading
//---------------------------------------------------------------------
unsigned TCAddConstraint_Multithreading::MyThreadProc(ULONG i)
{
HRESULT hr;
if (i>= nThreads)
return 0;
Sleep(0); // switch the context
hr = m_pITDWC->AddConstraint(m_prgTableID[i], &m_rgConstraintDesc[i]);
Sleep(0); // switch the context
m_rgResult[i] = hr;
return 1;
} //TCAddConstraint_Multithreading::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Each thread creates a different constraint
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Multithreading::Variation_1()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
DBORDINAL rgCol[] = {1};
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(m_rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
memset(m_rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
if (0 == i)
{
pConsDesc = new CPrimaryKeyCons(m_rgConstraintDesc+i);
TESTC_(((CPrimaryKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else if (i%2)
{
pConsDesc = new CUniqueCons(m_rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else
{
pConsDesc = new CForeignKeyCons(m_rgConstraintDesc+i);
TESTC_(((CForeignKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1, rgCol, &ReferencedTable, 1, rgCol, m_SupportedMatchType), S_OK);
}
pConsDesc->MakeConstraintName();
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (!CHECK(m_rgResult[i], S_OK))
{
if ( m_rgConstraintDesc[i].pConstraintID
&& DBKIND_NAME == m_rgConstraintDesc[i].pConstraintID->eKind
&& m_rgConstraintDesc[i].pConstraintID->uName.pwszName)
odtLog << "Constraint " << m_rgConstraintDesc[i].pConstraintID->uName.pwszName << " failed to be added\n";
else
odtLog << "Constraint no " << i << " failed to be added\n";
COMPARE(CheckResult(m_rgResult[i], cValidHRes, rgValidHRes), TRUE);
}
else
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(1, &m_rgConstraintDesc[i]), S_OK);
}
}
}
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &m_rgConstraintDesc, TRUE), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Some of the threads try to create the same constraint name
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Multithreading::Variation_2()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
const ULONG cSameName = 5;
DBORDINAL cDuplicates = 0;
DBORDINAL rgCol[] = {1};
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_PROVIDER(cSameName <= nThreads);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(m_rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
memset(m_rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
if (0 == i)
{
pConsDesc = new CPrimaryKeyCons(m_rgConstraintDesc+i);
TESTC_(((CPrimaryKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else if (i%2)
{
pConsDesc = new CUniqueCons(m_rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else
{
pConsDesc = new CForeignKeyCons(m_rgConstraintDesc+i);
TESTC_(((CForeignKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1, rgCol, &ReferencedTable, 1, rgCol, m_SupportedMatchType), S_OK);
}
if (0 == i || i >= cSameName)
pConsDesc->MakeConstraintName();
else
// several constraints have the same name
pConsDesc->SetConstraintID(m_rgConstraintDesc[0].pConstraintID);
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (S_OK != m_rgResult[i])
{
COMPARE(CompareDBID(*m_rgConstraintDesc[0].pConstraintID,
*m_rgConstraintDesc[i].pConstraintID), TRUE);
if (CHECK(m_rgResult[i], DB_E_DUPLICATECONSTRAINTID))
cDuplicates++;
if ( m_rgConstraintDesc[i].pConstraintID
&& DBKIND_NAME == m_rgConstraintDesc[i].pConstraintID->eKind
&& m_rgConstraintDesc[i].pConstraintID->uName.pwszName)
odtLog << "Constraint " << m_rgConstraintDesc[i].pConstraintID->uName.pwszName << " failed to be added\n";
else
odtLog << "Constraint no " << i << " failed to be added\n";
}
else
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(1, &m_rgConstraintDesc[i]), S_OK);
}
}
}
// exactly cSameName - 1 ops should have failed
TESTC(cSameName - 1 == cDuplicates);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &m_rgConstraintDesc, TRUE), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(3)
//*-----------------------------------------------------------------------
// @mfunc Unique constraints with disjoint columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Multithreading::Variation_3()
{
TBEGIN
ULONG cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
DBORDINAL iCol;
DBORDINAL cConsDescs = 0;
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_PROVIDER(nThreads <= BaseTable.CountColumnsOnTable());
BaseTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, BaseTable.GetTableName());
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(m_rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
memset(m_rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (cThreads=0, iCol=1; iCol <= BaseTable.CountColumnsOnTable() && cThreads < nThreads; iCol++)
{
CCol col;
TESTC_(BaseTable.GetColInfo(iCol, col), S_OK);
// Generally, setting unique constraints on BLOBs fail
// Note: col.GetColumnSize returns length for string data types and we need size in bytes
// so multiply ColumnSize by 2 for WSTR
if (col.GetIsLong() ||
(col.GetIsFixedLength() && (col.GetColumnSize() * (col.GetProviderType()==DBTYPE_WSTR ? 2:1) > cMaxColLengthPerCons)))
continue;
m_rgResult[cThreads] = -1;
m_prgTableID[cThreads] = &BaseTable.GetTableIDRef();
pConsDesc = new CUniqueCons(m_rgConstraintDesc+cThreads);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, iCol), S_OK);
pConsDesc->MakeConstraintName();
rgThreadParam[cThreads].pObject = this;
rgThreadParam[cThreads].i = cThreads;
cThreads++;
}
cConsDescs = cThreads;
// start threads
for (i=0; i<cThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(cThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< cThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i< cThreads; i++)
{
if (CHECK(m_rgResult[i], S_OK))
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(1, &m_rgConstraintDesc[i]), S_OK);
}
}
}
CLEANUP:
BaseTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cConsDescs, &m_rgConstraintDesc, TRUE), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(4)
//*-----------------------------------------------------------------------
// @mfunc Unique constraints with overlapping columns
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Multithreading::Variation_4()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_PROVIDER(nThreads <= BaseTable.CountColumnsOnTable());
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(m_rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
memset(m_rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
pConsDesc = new CUniqueCons(m_rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
pConsDesc->MakeConstraintName();
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (CHECK(m_rgResult[i], S_OK))
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(1, &m_rgConstraintDesc[i]), S_OK);
}
}
}
CLEANUP:
BaseTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &m_rgConstraintDesc, TRUE), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(5)
//*-----------------------------------------------------------------------
// @mfunc All constraint IDs are generated by the provider
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCAddConstraint_Multithreading::Variation_5()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
DBORDINAL rgCol[] = {1};
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_DUPLICATECONSTRAINTID,
DB_E_BADCONSTRAINTID,
DB_E_BADCONSTRAINTTYPE,
DB_E_BADUPDATEDELETERULE,
DB_E_BADMATCHTYPE,
DB_E_BADDEFERRABILITY,
DB_E_BADCONSTRAINTFORM,
DB_E_NOCOLUMN,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(m_rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
memset(m_rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
if (0 == i)
{
pConsDesc = new CPrimaryKeyCons(m_rgConstraintDesc+i);
TESTC_(((CPrimaryKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else if (i%2)
{
pConsDesc = new CUniqueCons(m_rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else
{
pConsDesc = new CForeignKeyCons(m_rgConstraintDesc+i);
TESTC_(((CForeignKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1, rgCol, &ReferencedTable, 1, rgCol, m_SupportedMatchType), S_OK);
}
pConsDesc->SetConstraintID(NULL);
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (CHECK(m_rgResult[i], S_OK))
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK)
&& m_rgConstraintDesc[i].pConstraintID
)
{
CHECK(Constraints.CheckIncludedConstraints(1, &m_rgConstraintDesc[i]), S_OK);
}
}
}
COMPARE(Constraints.GetConstrNo(), nThreads);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &m_rgConstraintDesc, TRUE), S_OK);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCAddConstraint_Multithreading::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCDropConstraint_Multithreading)
//*-----------------------------------------------------------------------
//| Test Case: TCDropConstraint_Multithreading - Multithreading test case for ITableDefinitionWithConstraints::DropConstraints
//| Created: 9/16/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCDropConstraint_Multithreading::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------
//
// @cmember Thread funtion for TCDropConstraint_Multithreading
//---------------------------------------------------------------------
unsigned TCDropConstraint_Multithreading::MyThreadProc(ULONG i)
{
HRESULT hr;
if (i>= nThreads)
return 0;
Sleep(0); // switch the context
hr = m_pITDWC->DropConstraint(m_prgTableID[i], m_prgConstraintID[i]);
Sleep(0); // switch the context
m_rgResult[i] = hr;
return 1;
} //TCDropConstraint_Multithreading::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Each thread drops a different constraint => all S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint_Multithreading::Variation_1()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
DBCONSTRAINTDESC *rgConstraintDesc = NULL;
DBORDINAL rgCol[] = {1};
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_NOCONSTRAINT,
DB_E_BADTABLEID,
DB_E_DROPRESTRICTED,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
SAFE_ALLOC(m_prgConstraintID, DBID*, nThreads);
memset(rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
// create a constraint
if (0 == i)
{
pConsDesc = new CPrimaryKeyCons(rgConstraintDesc+i);
TESTC_(((CPrimaryKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else if (i%2)
{
pConsDesc = new CUniqueCons(rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else
{
pConsDesc = new CForeignKeyCons(rgConstraintDesc+i);
TESTC_(((CForeignKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1, rgCol, &ReferencedTable, 1, rgCol, m_SupportedMatchType), S_OK);
}
pConsDesc->MakeConstraintName();
TESTC_(m_pITDWC->AddConstraint(m_prgTableID[i], &rgConstraintDesc[i]), S_OK);
m_prgConstraintID[i] = rgConstraintDesc[i].pConstraintID;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (!CHECK(m_rgResult[i], S_OK))
{
if ( rgConstraintDesc[i].pConstraintID
&& DBKIND_NAME == rgConstraintDesc[i].pConstraintID->eKind
&& rgConstraintDesc[i].pConstraintID->uName.pwszName)
odtLog << "Constraint " << rgConstraintDesc[i].pConstraintID->uName.pwszName << " failed to be added\n";
else
odtLog << "Constraint no " << i << " failed to be dropped\n";
COMPARE(CheckResult(m_rgResult[i], cValidHRes, rgValidHRes), TRUE);
}
else
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
COMPARE(NULL == Constraints[m_prgConstraintID[i]], TRUE);
}
}
}
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &rgConstraintDesc, TRUE), S_OK);
SAFE_FREE(m_prgConstraintID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Some threads try to drop the same constraint => S_OK and DB_E_NOCONSTRAINT
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCDropConstraint_Multithreading::Variation_2()
{
TBEGIN
DBORDINAL cThreads = nThreads;
CConsDesc *pConsDesc = NULL;
CTable ReferencedTable(m_pITDWC, (LPWSTR)gwszModuleName);
CTable BaseTable(m_pITDWC, (LPWSTR)gwszModuleName);
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
ULONG i;
DBCONSTRAINTDESC *rgConstraintDesc = NULL;
DBORDINAL rgCol[] = {1};
HRESULT rgValidHRes[] = { S_OK,
E_FAIL,
E_INVALIDARG,
DB_E_NOCONSTRAINT,
DB_E_BADTABLEID,
DB_E_DROPRESTRICTED,
DB_E_NOTABLE,
DB_E_TABLEINUSE,
DB_SEC_E_PERMISSIONDENIED,
XACT_E_XTIONEXISTS,
DB_E_SCHEMAVIOLATION
};
ULONG cValidHRes = NUMELEM(rgValidHRes);
CConstraints Constraints(m_pITDWC);
DBORDINAL ulFailed = 0;
const DBORDINAL cSameName = 5;
TESTC_PROVIDER(cSameName <= nThreads);
TESTC_(CreateTableWithNoNullableColumns(&BaseTable, 0), S_OK);
TESTC_(ReferencedTable.CreateTable(0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
TESTC_(AddUniqueConstraint(&ReferencedTable, 1), S_OK);
SAFE_ALLOC(m_prgTableID, DBID*, nThreads);
SAFE_ALLOC(rgConstraintDesc, DBCONSTRAINTDESC, nThreads);
SAFE_ALLOC(m_prgConstraintID, DBID*, nThreads);
memset(rgConstraintDesc, 0, nThreads * sizeof(DBCONSTRAINTDESC));
for (i=0; i< nThreads; i++)
{
m_rgResult[i] = -1;
m_prgTableID[i] = &BaseTable.GetTableIDRef();
// create a constraint
if (0 == i)
{
pConsDesc = new CPrimaryKeyCons(rgConstraintDesc+i);
TESTC_(((CPrimaryKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else if (i%2)
{
pConsDesc = new CUniqueCons(rgConstraintDesc+i);
TESTC_(((CUniqueCons*)pConsDesc)->SetConstraint(&BaseTable, 1), S_OK);
}
else
{
pConsDesc = new CForeignKeyCons(rgConstraintDesc+i);
TESTC_(((CForeignKeyCons*)pConsDesc)->SetConstraint(&BaseTable, 1, rgCol, &ReferencedTable, 1, rgCol, m_SupportedMatchType), S_OK);
}
pConsDesc->MakeConstraintName();
TESTC_(m_pITDWC->AddConstraint(m_prgTableID[i], &rgConstraintDesc[i]), S_OK);
if (i < cSameName)
m_prgConstraintID[i] = rgConstraintDesc[0].pConstraintID;
else
m_prgConstraintID[i] = rgConstraintDesc[i].pConstraintID;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
if (S_OK != m_rgResult[i])
{
CHECK(m_rgResult[i], DB_E_NOCONSTRAINT);
ulFailed++;
if ( rgConstraintDesc[i].pConstraintID
&& DBKIND_NAME == rgConstraintDesc[i].pConstraintID->eKind
&& rgConstraintDesc[i].pConstraintID->uName.pwszName)
odtLog << "Constraint " << rgConstraintDesc[i].pConstraintID->uName.pwszName << " failed to be added\n";
else
odtLog << "Constraint no " << i << " failed to be dropped\n";
COMPARE(CheckResult(m_rgResult[i], cValidHRes, rgValidHRes), TRUE);
}
else
{
// get all the constraints associated with the table
if ( m_prgTableID[i]
&& DBKIND_NAME == m_prgTableID[i]->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, m_prgTableID[i]->uName.pwszName, NULL, NULL, NULL), S_OK))
{
COMPARE(NULL == Constraints[m_prgConstraintID[i]], TRUE);
}
}
}
TESTC(cSameName - 1 == ulFailed);
CLEANUP:
BaseTable.DropTable();
ReferencedTable.DropTable();
SAFE_FREE(m_prgTableID);
CHECK(FreeConstraintDesc(&cThreads, &rgConstraintDesc, TRUE), S_OK);
SAFE_FREE(m_prgConstraintID);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCDropConstraint_Multithreading::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
// {{ TCW_TC_PROTOTYPE(TCCreateTableWithConstraints_Multithreading)
//*-----------------------------------------------------------------------
//| Test Case: TCCreateTableWithConstraints_Multithreading - Multithreading test case for ITableDefinitionWithConstraints::CreateTableWithConstraints
//| Created: 9/17/99
//*-----------------------------------------------------------------------
//*-----------------------------------------------------------------------
// @mfunc TestCase Initialization Routine
//
// @rdesc TRUE or FALSE
//
BOOL TCCreateTableWithConstraints_Multithreading::Init()
{
// {{ TCW_INIT_BASECLASS_CHECK
if(TCITableDefinition::Init())
// }}
{
if (m_pITDWC == NULL)
{
odtLog << "ITableDefinitionWithConstraints is not supported.\n";
return TEST_SKIPPED;
}
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------
//
// @cmember Thread funtion for TCCreateTableWithConstraints_Multithreading
//---------------------------------------------------------------------
unsigned TCCreateTableWithConstraints_Multithreading::MyThreadProc(ULONG i)
{
HRESULT hr;
if (i>= nThreads)
return 0;
Sleep(0); // switch the context
hr = m_pITDWC->CreateTableWithConstraints(
m_rgThreadParams[i].m_pUnkOuter,
m_rgThreadParams[i].m_pTableID,
m_rgThreadParams[i].m_cColumnDescs,
m_rgThreadParams[i].m_rgColumnDescs,
m_rgThreadParams[i].m_cConstraintDescs,
m_rgThreadParams[i].m_rgConstraintDescs,
*m_rgThreadParams[i].m_piid,
m_rgThreadParams[i].m_cPropertySets,
m_rgThreadParams[i].m_rgPropertySets,
m_rgThreadParams[i].m_ppTableID,
m_rgThreadParams[i].m_ppRowset
);
Sleep(0); // switch the context
m_rgThreadParams[i].m_hr = hr;
return 1;
} //TCCreateTableWithConstraints_Multithreading::MyThreadProc
// {{ TCW_VAR_PROTOTYPE(1)
//*-----------------------------------------------------------------------
// @mfunc Each thread builds different table => all S_OK
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Multithreading::Variation_1()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray[nThreads];
ULONG i;
CCol col;
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
CConstraints Constraints(m_pITDWC);
m_rgThreadParams = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, 1, (DBDEFERRABILITY)0), S_OK);
m_rgThreadParams = new CCTWCThreadParam[nThreads];
for (i=0; i< nThreads; i++)
{
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
m_rgThreadParams[i].m_hr = E_FAIL;
m_rgThreadParams[i].m_op = CREATETABLE_CONSTRAINTS;
m_rgThreadParams[i].m_pUnkOuter = NULL;
m_rgThreadParams[i].m_pTableID = NULL;
m_rgThreadParams[i].m_cColumnDescs = cColumnDesc;
m_rgThreadParams[i].m_rgColumnDescs = rgColumnDesc;
// create the array of constraints
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray[i].AddConsDesc(consUnique);
ConsDescArray[i].AddConsDesc(consForeignKey);
ConsDescArray[i].AddConsDesc(consPrimaryKey);
m_rgThreadParams[i].m_cConstraintDescs = ConsDescArray[i];
m_rgThreadParams[i].m_rgConstraintDescs = ConsDescArray[i];
m_rgThreadParams[i].m_piid = NULL;
m_rgThreadParams[i].m_cPropertySets = 0;
m_rgThreadParams[i].m_rgPropertySets= NULL;
SAFE_ALLOC(m_rgThreadParams[i].m_ppTableID, DBID*, 1);
//*m_rgThreadParams[i].m_ppTableID = NULL;
m_rgThreadParams[i].m_ppRowset = NULL;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
DBID *pTableID = NULL;
if (m_rgThreadParams[i].m_ppTableID)
pTableID = (*m_rgThreadParams[i].m_ppTableID);
else if (m_rgThreadParams[i].m_pTableID)
pTableID = m_rgThreadParams[i].m_pTableID;
if (CHECK(m_rgThreadParams[i].m_hr, S_OK))
{
COMPARE(NULL != pTableID, TRUE);
// get all the constraints associated with the table
if ( pTableID
&& DBKIND_NAME == pTableID->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(m_rgThreadParams[i].m_cConstraintDescs, m_rgThreadParams[i].m_rgConstraintDescs), S_OK);
}
// drop the newly created table
CHECK(m_pITableDefinition->DropTable(pTableID), S_OK);
}
}
CLEANUP:
delete [] m_rgThreadParams;
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_VAR_PROTOTYPE(2)
//*-----------------------------------------------------------------------
// @mfunc Some threads build the same table => S_OK and DB_E_DUPLICATETABLEID
//
// @rdesc TEST_PASS or TEST_FAIL
//
int TCCreateTableWithConstraints_Multithreading::Variation_2()
{
TBEGIN
CTable ReferencedTable(m_pThisTestModule->m_pIUnknown2, (LPWSTR)gwszModuleName);
DBCOLUMNDESC *rgColumnDesc = NULL;
DBORDINAL cColumnDesc = 0;
CConsDescArray ConsDescArray[nThreads];
ULONG i;
CCol col;
unsigned rgIDThread[nThreads];
HANDLE hrgThread[nThreads];
CInParam rgThreadParam[nThreads];
CConstraints Constraints(m_pITDWC);
WCHAR *pwszBaseName = NULL;
WCHAR number[3];
DBORDINAL cSameName = 5;
DBORDINAL cDuplicates = 0;
TESTC_PROVIDER(cSameName <= nThreads);
m_rgThreadParams = NULL;
DuplicateColumnDesc(m_rgColumnDesc, m_cColumnDesc, &rgColumnDesc);
cColumnDesc = m_cColumnDesc;
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(rgColumnDesc, cColumnDesc);
SetProperty(&rgColumnDesc[0].rgPropertySets, &rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(ReferencedTable.CreateTable(0, 0), S_OK);
ReferencedTable.AddInfoFromColumnsSchemaRowset(m_pITDWC, ReferencedTable.GetTableName());
// make the referenced columns unique
TESTC_(AddUniqueConstraint(&ReferencedTable, 1, (DBDEFERRABILITY)0), S_OK);
m_pTable->MakeTableName(NULL);
pwszBaseName = m_pTable->GetTableName();
m_rgThreadParams = new CCTWCThreadParam[nThreads];
for (i=0; i< nThreads; i++)
{
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_SupportedMatchType);
m_rgThreadParams[i].m_hr = E_FAIL;
m_rgThreadParams[i].m_op = CREATETABLE_CONSTRAINTS;
m_rgThreadParams[i].m_pUnkOuter = NULL;
SAFE_ALLOC(m_rgThreadParams[i].m_pTableID, DBID, 1);
m_rgThreadParams[i].m_pTableID->eKind = DBKIND_NAME;
SAFE_ALLOC(m_rgThreadParams[i].m_pTableID->uName.pwszName, WCHAR,
(3+wcslen(pwszBaseName)));
wcscpy(m_rgThreadParams[i].m_pTableID->uName.pwszName, pwszBaseName);
swprintf(number, L"%02d", (i < cSameName)? 0: i);
wcscat(m_rgThreadParams[i].m_pTableID->uName.pwszName, number);
m_rgThreadParams[i].m_cColumnDescs = cColumnDesc;
m_rgThreadParams[i].m_rgColumnDescs = rgColumnDesc;
// create the array of constraints
// set a unique constraint on the second column
consUnique.AddColumn(&rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(ReferencedTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&ReferencedTable.GetTableID());
// add all constraint to the array
ConsDescArray[i].AddConsDesc(consUnique);
ConsDescArray[i].AddConsDesc(consForeignKey);
ConsDescArray[i].AddConsDesc(consPrimaryKey);
m_rgThreadParams[i].m_cConstraintDescs = ConsDescArray[i];
m_rgThreadParams[i].m_rgConstraintDescs = ConsDescArray[i];
m_rgThreadParams[i].m_piid = NULL;
m_rgThreadParams[i].m_cPropertySets = 0;
m_rgThreadParams[i].m_rgPropertySets= NULL;
m_rgThreadParams[i].m_ppTableID = NULL;
m_rgThreadParams[i].m_ppRowset = NULL;
rgThreadParam[i].pObject = this;
rgThreadParam[i].i = i;
}
// start the threads
for (i=0; i<nThreads; i++)
{
hrgThread[i] = (HANDLE)_beginthreadex(NULL, 0, ThreadProc,
(void*)&rgThreadParam[i],
0,
&rgIDThread[i]); // input param
TESTC(0 != hrgThread[i]);
}
WaitForMultipleObjects(nThreads, (CONST HANDLE*)hrgThread, TRUE, 1000);
Sleep(1000);
for (i=0; i< nThreads; i++)
CloseHandle(hrgThread[i]);
for (i=0; i<nThreads; i++)
{
DBID *pTableID = NULL;
if (m_rgThreadParams[i].m_ppTableID)
pTableID = (*m_rgThreadParams[i].m_ppTableID);
else if (m_rgThreadParams[i].m_pTableID)
pTableID = m_rgThreadParams[i].m_pTableID;
if (S_OK == m_rgThreadParams[i].m_hr)
{
COMPARE(NULL != pTableID, TRUE);
// get all the constraints associated with the table
if ( pTableID
&& DBKIND_NAME == pTableID->eKind
&& CHECK(Constraints.GetConstraints(NULL, NULL, pTableID->uName.pwszName, NULL, NULL, NULL), S_OK))
{
CHECK(Constraints.CheckIncludedConstraints(m_rgThreadParams[i].m_cConstraintDescs, m_rgThreadParams[i].m_rgConstraintDescs), S_OK);
}
// drop the newly created table
CHECK(m_pITableDefinition->DropTable(pTableID), S_OK);
}
else
{
if (CHECK(m_rgThreadParams[i].m_hr, DB_E_DUPLICATETABLEID))
cDuplicates++;
}
}
TESTC(cDuplicates + 1 == cSameName);
CLEANUP:
delete [] m_rgThreadParams;
CHECK(ReferencedTable.DropTable(), S_OK);
ReleaseColumnDesc(rgColumnDesc, cColumnDesc);
TRETURN
}
// }} TCW_VAR_PROTOTYPE_END
// {{ TCW_TERMINATE_METHOD
//*-----------------------------------------------------------------------
// @mfunc TestCase Termination Routine
//
// @rdesc TEST_PASS or TEST_FAIL
//
BOOL TCCreateTableWithConstraints_Multithreading::Terminate()
{
// TO DO: Add your own code here
// {{ TCW_TERM_BASECLASS_CHECK2
return(TCITableDefinition::Terminate());
} // }}
// }} TCW_TERMINATE_METHOD_END
// }} TCW_TC_PROTOTYPE_END
///////////////////////////////////////////////////////////////////////////
//
// CAddConstraintTxnAdapter class
//
///////////////////////////////////////////////////////////////////////////
BOOL CAddConstraintTxnAdapter::BeforeTransaction()
{
TBEGIN
// create a table and populate it
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_Table, 0, 0), S_OK);
m_Table.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_Table.GetTableName());
// get the list of the constraints on the table
m_pConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pConstraints->GetConstraints(NULL, NULL, m_Table.GetTableName(), NULL, NULL, NULL), S_OK);
CLEANUP:
TRETURN
} //CAddConstraintTxnAdapter::BeforeTransaction
///////////////////////////////////////////////////////////////////////////
//
// CAddUniqueConsTxnAdapter class
//
///////////////////////////////////////////////////////////////////////////
BOOL CAddUniqueConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CCol col;
TESTC(CAddConstraintTxnAdapter::BeforeTransaction());
// select column
TESTC_(m_Table.GetColInfo(1, col), S_OK);
// add the constraint
m_pCons = new CUniqueCons();
((CUniqueCons*)m_pCons)->AddColumn(col.GetColID());
CLEANUP:
TRETURN
} //CAddUniqueConsTxnAdapter::BeforeTransaction
HRESULT CAddUniqueConsTxnAdapter::InsideTransactionScope()
{
HRESULT hr = E_FAIL;
CCol col;
CHECK(CAddConstraintTxnAdapter::InsideTransactionScope(), S_OK);
// create a table
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_TransactedTable, 0, 0), S_OK);
m_TransactedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
// select column
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
// add the constraint
m_pTransactedTableCons= new CUniqueCons();
((CUniqueCons*)m_pTransactedTableCons)->AddColumn(col.GetColID());
hr = m_pTCITableDefinition->AddConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_TransactedTable.GetTableID(),
*m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddUniqueConsTxnAdapter::InsideTransactionScope
HRESULT CAddUniqueConsTxnAdapter::InsideTransactionOnDDLLock()
{
HRESULT hr = E_FAIL;
CCol col;
CHECK(CAddConstraintTxnAdapter::InsideTransactionOnDDLLock(), S_OK);
// create a table and populate it
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_TransactedTable, 0, 0), S_OK);
m_TransactedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// select column
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
// add the constraint
m_pTransactedTableCons = new CUniqueCons();
((CUniqueCons*)m_pTransactedTableCons)->AddColumn(col.GetColID());
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
hr = m_pTCITableDefinition->pITDWC()->AddConstraint(
&m_TransactedTable.GetTableID(),
*m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddUniqueConsTxnAdapter::InsideTransactionOnDDLLock
BOOL CAddUniqueConsTxnAdapter::CheckCompletion()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckCompletion());
// check unique constraint here
TESTC_(m_Table.Insert(5), S_OK);
TESTC_(m_Table.Insert(5), DB_E_INTEGRITYVIOLATION);
ASSERT(m_pTransactedTableCons);
TESTC_(m_TransactedTable.Insert(5), S_OK);
TESTC_(m_TransactedTable.Insert(5), DB_E_INTEGRITYVIOLATION);
CLEANUP:
TRETURN
} //CAddUniqueConsTxnAdapter::CheckCompletion
BOOL CAddUniqueConsTxnAdapter::CheckRollBack()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckRollBack());
// check unique constraint here
TESTC_(m_Table.Insert(5), S_OK);
TESTC_(m_Table.Insert(5), S_OK);
CLEANUP:
TRETURN
} //CAddUniqueConsTxnAdapter::CheckRollBack
///////////////////////////////////////////////////////////////////////////
//
// CAddPrimaryKeyConsTxnAdapter class
//
///////////////////////////////////////////////////////////////////////////
BOOL CAddPrimaryKeyConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CCol col;
TESTC(CAddConstraintTxnAdapter::BeforeTransaction());
// select column
TESTC_(m_Table.GetColInfo(1, col), S_OK);
// add the constraint
m_pCons = new CPrimaryKeyCons();
((CPrimaryKeyCons*)m_pCons)->AddColumn(col.GetColID());
CLEANUP:
TRETURN
} //CAddPrimaryKeyConsTxnAdapter::BeforeTransaction
//////////////////////////////////////////////////////////////////
//
// CAddFKConsTxnAdapter class
//
//////////////////////////////////////////////////////////////////
BOOL CAddFKConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CCol col;
CUniqueCons uniqueCons;
// create a reference table and populate it
TESTC_(m_ReferencedTable.CreateTable(4, 0), S_OK);
m_ReferencedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_ReferencedTable.GetTableName());
// add unique constraint on the first column
TESTC_(m_ReferencedTable.GetColInfo(1, col), S_OK);
uniqueCons.AddColumn(col.GetColID());
CHECK(m_pTCITableDefinition->AddConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_ReferencedTable.GetTableID(), uniqueCons), S_OK);
// create a table and populate it
TESTC_(m_Table.CreateTable(4, 0), S_OK);
m_Table.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_Table.GetTableName());
// get the list of the constraints on the table
m_pConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pConstraints->GetConstraints(NULL, NULL, m_Table.GetTableName(), NULL, NULL, NULL), S_OK);
// prepare the constraint
m_pCons = new CForeignKeyCons();
// select column to be foreign key
TESTC_(m_Table.GetColInfo(1, col), S_OK);
((CForeignKeyCons*)m_pCons)->AddForeignKeyColumn(col.GetColID());
TESTC_(m_ReferencedTable.GetColInfo(1, col), S_OK);
((CForeignKeyCons*)m_pCons)->AddColumn(col.GetColID());
((CForeignKeyCons*)m_pCons)->SetReferencedTableID(&m_ReferencedTable.GetTableID());
CLEANUP:
TRETURN
} //CAddFKConsTxnAdapter::BeforeTransaction
HRESULT CAddFKConsTxnAdapter::InsideTransactionScope()
{
HRESULT hr = E_FAIL;
CCol col;
CHECK(CAddConstraintTxnAdapter::InsideTransactionScope(), S_OK);
// create a table and populate it
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_TransactedTable, 0, 0), S_OK);
m_TransactedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
// prepare the constraint
m_pTransactedTableCons = new CForeignKeyCons();
// select column
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
((CForeignKeyCons*)m_pTransactedTableCons)->AddForeignKeyColumn(col.GetColID());
TESTC_(m_ReferencedTable.GetColInfo(1, col), S_OK);
((CForeignKeyCons*)m_pTransactedTableCons)->AddColumn(col.GetColID());
((CForeignKeyCons*)m_pTransactedTableCons)->SetReferencedTableID(&m_ReferencedTable.GetTableID());
hr = m_pTCITableDefinition->AddConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_TransactedTable.GetTableID(),
*m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddFKConsTxnAdapter::InsideTransactionScope
HRESULT CAddFKConsTxnAdapter::InsideTransactionOnDDLLock()
{
HRESULT hr = E_FAIL;
CCol col;
CHECK(CAddConstraintTxnAdapter::InsideTransactionOnDDLLock(), S_OK);
// create a table and populate it
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_TransactedTable, 0, 0), S_OK);
m_TransactedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// select column
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
// prepare the constraint
m_pTransactedTableCons = new CForeignKeyCons();
((CForeignKeyCons*)m_pTransactedTableCons)->AddColumn(col.GetColID());
TESTC_(m_ReferencedTable.GetColInfo(1, col), S_OK);
((CForeignKeyCons*)m_pTransactedTableCons)->AddForeignKeyColumn(col.GetColID());
((CForeignKeyCons*)m_pTransactedTableCons)->SetReferencedTableID(&m_ReferencedTable.GetTableID());
hr = m_pTCITableDefinition->pITDWC()->AddConstraint(
&m_TransactedTable.GetTableID(),
*m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddFKConsTxnAdapter::InsideTransactionOnDDLLock
BOOL CAddFKConsTxnAdapter::CheckCompletion()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckCompletion());
// check foreign key constraint here
TESTC_(m_Table.Insert(2), S_OK);
// there isn't a row with seed 15 in the referenced table
TESTC_(m_Table.Insert(15), DB_E_INTEGRITYVIOLATION);
CLEANUP:
TRETURN
} //CAddFKConsTxnAdapter::CheckCompletion
BOOL CAddFKConsTxnAdapter::CheckRollBack()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckRollBack());
// check foreign key constraint here
TESTC_(m_Table.Insert(2), S_OK);
TESTC_(m_Table.Insert(15), S_OK);
CLEANUP:
TRETURN
} //CAddFKConsTxnAdapter::CheckRollBack
//////////////////////////////////////////////////////////////////
//
// CAddCheckConsTxnAdapter class
//
//////////////////////////////////////////////////////////////////
BOOL CAddCheckConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CCol col;
// create a table and populate it
TESTC_(m_Table.CreateTable(0, 0), S_OK);
m_Table.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_Table.GetTableName());
// get the list of the constraints on the table
m_pConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pConstraints->GetConstraints(NULL, NULL, m_Table.GetTableName(), NULL, NULL, NULL), S_OK);
// select column to be foreign key
TESTC_(m_Table.GetColInfo(1, col), S_OK);
// prepare the constraint
m_pCons = new CCheckCons();
// every 3rd row has a negative value
CHECK(((CCheckCons*)m_pCons)->SetLTCheckConstraint(&m_Table, col.GetColNum(), 6), S_OK);
CLEANUP:
TRETURN
} //CAddCheckConsTxnAdapter::BeforeTransaction
HRESULT CAddCheckConsTxnAdapter::InsideTransactionScope()
{
TBEGIN
CCol col;
HRESULT hr = E_FAIL;
CHECK(CAddConstraintTxnAdapter::InsideTransactionScope(), S_OK);
// create a table and populate it
TESTC_(m_TransactedTable.CreateTable(0, 0), S_OK);
m_Table.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
// select column to be foreign key
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
// prepare the constraint
m_pTransactedTableCons = new CCheckCons();
// every 3rd row has a negative value
CHECK(((CCheckCons*)m_pTransactedTableCons)->SetLTCheckConstraint(&m_TransactedTable, col.GetColNum(), 6), S_OK);
hr = m_pTCITableDefinition->AddConstraintAndCheck(
m_pTCITableDefinition->pITDWC(),
&m_TransactedTable.GetTableID(), *m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddCheckConsTxnAdapter::InsideTransactionScope
HRESULT CAddCheckConsTxnAdapter::InsideTransactionOnDDLLock()
{
TBEGIN
CCol col;
HRESULT hr = E_FAIL;
CHECK(CAddConstraintTxnAdapter::InsideTransactionOnDDLLock(), S_OK);
// create a table and populate it
TESTC_(m_TransactedTable.CreateTable(0, 0), S_OK);
m_TransactedTable.AddInfoFromColumnsSchemaRowset(g_pIOpenRowset, m_TransactedTable.GetTableName());
// get the list of the constraints on the table
m_pTxnConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pTxnConstraints->GetConstraints(NULL, NULL, m_TransactedTable.GetTableName(), NULL, NULL, NULL), S_OK);
// select column to be foreign key
TESTC_(m_TransactedTable.GetColInfo(1, col), S_OK);
// prepare the constraint
m_pTransactedTableCons = new CCheckCons();
// every 3rd row has a negative value
CHECK(((CCheckCons*)m_pTransactedTableCons)->SetLTCheckConstraint(&m_TransactedTable, col.GetColNum(), 6), S_OK);
hr = m_pTCITableDefinition->pITDWC()->AddConstraint(
&m_TransactedTable.GetTableID(), *m_pTransactedTableCons);
CLEANUP:
return hr;
} //CAddCheckConsTxnAdapter::InsideTransactionOnDDLLock
BOOL CAddCheckConsTxnAdapter::CheckCompletion()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckCompletion());
// check foreign key constraint here
TESTC_(m_Table.Insert(4), S_OK);
TESTC_(m_Table.Insert(8), DB_E_INTEGRITYVIOLATION);
TESTC_(m_TransactedTable.Insert(4), S_OK);
TESTC_(m_TransactedTable.Insert(8), DB_E_INTEGRITYVIOLATION);
CLEANUP:
TRETURN
} //CAddCheckConsTxnAdapter::CheckCompletion
BOOL CAddCheckConsTxnAdapter::CheckRollBack()
{
TBEGIN
ASSERT(m_pCons);
TESTC(CAddConstraintTxnAdapter::CheckRollBack());
// check constraint here
TESTC_(m_Table.Insert(4), S_OK);
TESTC_(m_Table.Insert(8), S_OK);
CLEANUP:
TRETURN
} //CAddCheckConsTxnAdapter::CheckRollBack
////////////////////////////////////////////////////////
//
// class CCreateTableWithConsTxnAdapter
//
////////////////////////////////////////////////////////
BOOL CCreateTableWithConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CUniqueCons consUnique;
CPrimaryKeyCons consPrimaryKey;
CForeignKeyCons consForeignKey(NULL, m_pTCITableDefinition->SupportedMatchType());
DBORDINAL rgReferencedCol[] = {1};
CCol col;
CList <WCHAR*, WCHAR*> ListNativeTemp;
CList <DBTYPE, DBTYPE> ListDataTypes;
CList <CCol, CCol&> ColList;
// create table name
m_Table.MakeTableName(NULL);
// get the provider types list
// all types appear in CreateColList, so I don't have to use CreateTypeColInfo
m_Table.CreateTypeColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
m_Table.DuplicateColList(ColList);
// in m_rgColumnDesc I would rather load just the types prepared for table creation
m_Table.CreateColInfo(ListNativeTemp, ListDataTypes, ALLTYPES);
// build the column description array
m_Table.BuildColumnDescs(&m_rgColumnDesc);
m_cColumnDesc = m_Table.CountColumnsOnTable();
m_Table.SetBuildColumnDesc(FALSE);
// release the properties on all column and make the first column not nullable
ReleaseAllColumnPropSets(m_rgColumnDesc, m_cColumnDesc);
m_pTCITableDefinition->SetProperty(&m_rgColumnDesc[0].rgPropertySets, &m_rgColumnDesc[0].cPropertySets,
DBPROP_COL_NULLABLE,
VT_BOOL, (LPVOID)VARIANT_FALSE,
DBPROPOPTIONS_REQUIRED);
// create support for foreign key constraint
TESTC_(m_RefTable.CreateTable(0, 0), S_OK);
m_RefTable.AddInfoFromColumnsSchemaRowset(m_pTCITableDefinition->pITDWC(), m_RefTable.GetTableName());
// make the referenced columns unique
TESTC_(m_pTCITableDefinition->AddUniqueConstraint(&m_RefTable, rgReferencedCol[0], (DBDEFERRABILITY)0), S_OK);
// set a unique constraint on the second column
consUnique.AddColumn(&m_rgColumnDesc[1].dbcid);
// set a primary key on the first column of the table
consPrimaryKey.AddColumn(&m_rgColumnDesc[0].dbcid);
// set a simple foreign key constraint
TESTC_(m_RefTable.GetColInfo(1, col), S_OK);
consForeignKey.AddColumn(col.GetColID());
consForeignKey.AddForeignKeyColumn(&m_rgColumnDesc[0].dbcid);
consForeignKey.SetReferencedTableID(&m_RefTable.GetTableID());
// add all constraint to the array
m_ConsDescArray.AddConsDesc(consUnique);
m_ConsDescArray.AddConsDesc(consForeignKey);
m_ConsDescArray.AddConsDesc(consPrimaryKey);
// get the list of the constraints on the table
m_pConstraints = new CConstraints(g_pIOpenRowset);
TESTC_(m_pConstraints->GetConstraints(NULL, NULL, m_Table.GetTableName(), NULL, NULL, NULL), S_OK);
CLEANUP:
TRETURN
} //CCreateTableWithConsTxnAdapter::BeforeTransaction
///////////////////////////////////////////////////////////
//
// class CDropConsTxnAdapter
//
///////////////////////////////////////////////////////////
BOOL CDropConsTxnAdapter::BeforeTransaction()
{
TBEGIN
CCol col;
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_Table, 0, 0), S_OK);
m_Table.AddInfoFromColumnsSchemaRowset(m_pTCITableDefinition->pITDWC(), m_Table.GetTableName());
TESTC_(pTCITableDefinition()->CreateTableWithNoNullableColumns(&m_RefTable, 0, 0), S_OK);
m_RefTable.AddInfoFromColumnsSchemaRowset(m_pTCITableDefinition->pITDWC(), m_RefTable.GetTableName());
TESTC_(m_pTCITableDefinition->AddUniqueConstraint(&m_RefTable, 1), S_OK);
// choose 1 column and create a unique constraint on them
TESTC_(m_Table.GetColInfo(1, col), S_OK);
m_pFKCons = new CForeignKeyCons(NULL, m_pTCITableDefinition->SupportedMatchType());
m_pFKCons->AddForeignKeyColumn(col.GetColID());
TESTC_(m_RefTable.GetColInfo(1, col), S_OK);
m_pFKCons->AddColumn(col.GetColID());
m_pFKCons->SetReferencedTableID(&m_RefTable.GetTableID());
CHECK(m_pTCITableDefinition->AddConstraintAndCheck(m_pTCITableDefinition->pITDWC(), &m_Table.GetTableID(), *m_pFKCons), S_OK);
// Add constraint
m_pPKCons = new CPrimaryKeyCons();
m_pPKCons->AddColumn(col.GetColID());
CHECK(m_pTCITableDefinition->AddConstraintAndCheck(m_pTCITableDefinition->pITDWC(), &m_Table.GetTableID(), *m_pPKCons), S_OK);
// Add constraint
m_pUniqueCons = new CUniqueCons();
m_pUniqueCons->AddColumn(col.GetColID());
CHECK(m_pTCITableDefinition->AddConstraintAndCheck(m_pTCITableDefinition->pITDWC(), &m_Table.GetTableID(), *m_pUniqueCons), S_OK);
// Add constraint
m_pCheckCons = new CCheckCons();
m_pCheckCons->SetLTCheckConstraint(&m_Table, col.GetColNum(), 5);
CHECK(m_pTCITableDefinition->AddConstraintAndCheck(m_pTCITableDefinition->pITDWC(), &m_Table.GetTableID(), *m_pCheckCons), S_OK);
// get the list of the constraints on the table
m_pConstraints = new CConstraints(g_pIOpenRowset);
CHECK(m_pConstraints->GetConstraints(NULL, NULL, m_Table.GetTableName(), NULL, NULL, NULL), S_OK);
CLEANUP:
TRETURN
} //CDropConsTxnAdapter::BeforeTransaction
HRESULT CTransactionLocal::StartTransaction(
IUnknown *pISessionUnknown,
// arguments for ITransactionLocal::StartTransaction
ISOLEVEL isoLevel,
ULONG isoFlags,
ITransactionOptions *pOtherOptions
)
{
HRESULT hr = E_FAIL;
CPropSets PropSets;
DBPROP *pSupportedTxnDDL;
m_lSupportedTxnDDL = DBPROPVAL_TC_NONE;
if (!pISessionUnknown)
return E_INVALIDARG;
m_Session = pISessionUnknown;
TESTC_(m_Session.GetDataSource(m_DataSource), S_OK);
// get DBPROP_SUPPORTEDTXNDDL
TESTC_(m_DataSource.GetProperties(&PropSets), S_OK);
pSupportedTxnDDL = PropSets.FindProperty(DBPROP_SUPPORTEDTXNDDL, DBPROPSET_DATASOURCEINFO);
TESTC(!pSupportedTxnDDL || (VT_I4 == pSupportedTxnDDL->vValue.vt));
if (pSupportedTxnDDL)
m_lSupportedTxnDDL = V_I4(&pSupportedTxnDDL->vValue);
else if ((ITransactionLocal*)m_Session)
m_lSupportedTxnDDL = DBPROPVAL_TC_ALL;
// check the relation between the property and the interface
TESTC( (NULL != (ITransactionLocal*)m_Session)
|| (!pSupportedTxnDDL || (DBPROPVAL_TC_NONE == m_lSupportedTxnDDL)));
// if the interface is not supported just return
if (NULL == (ITransactionLocal*)m_Session)
return S_OK;
hr = ((ITransactionLocal*)m_Session)->StartTransaction(isoLevel, isoFlags, pOtherOptions, NULL);
if (hr==S_OK)
// Set the flag that we're inside transaction
CConsDesc::s_fInsideTransaction = TRUE;
CLEANUP:
return hr;
} //CTransactionLocal::StartTransaction
BOOL CTransactionLocal::DoTransactionTest(
IUnknown *pISessionUnknown,
CTransactionAdapter *pTAdapter,
// arguments for ITransactionLocal::Abort / Commit
BOOL fDDL, // whether or not this is a DDL call
BOOL fAbortCommit, // whether to abort or commit
BOOL fRetaining // if it's retaining or not
)
{
TBEGIN
HRESULT hr;
ULONG cIsoLevel, i;
ISOLEVEL rgIsoLevel[] = {ISOLATIONLEVEL_BROWSE, ISOLATIONLEVEL_CURSORSTABILITY,
ISOLATIONLEVEL_ISOLATED, ISOLATIONLEVEL_CHAOS};
cIsoLevel = NUMELEM(rgIsoLevel);
TESTC(NULL != pISessionUnknown);
TESTC(NULL != pTAdapter);
m_pTAdapter = pTAdapter;
// do work / testing that precedes transaction
COMPARE(m_pTAdapter->BeforeTransaction(), TRUE);
// start the transaction
for (i=0; i<cIsoLevel; i++)
{
if (S_OK == (hr = StartTransaction(pISessionUnknown, rgIsoLevel[i], 0, NULL)))
break;
}
if (cIsoLevel < i)
return E_FAIL;
// TESTC_(m_pTAdapter->pTCITableDefinition()->StartTransaction(), S_OK);
// TESTC_(StartTransaction(pISessionUnknown, isoLevel, isoFlags, pOtherOptions), S_OK);
// check that we have a local transaction; return if not
TESTC_PROVIDER(NULL != (ITransactionLocal*)m_Session);
if (!fDDL)
{ TESTC_(m_pTAdapter->InsideTransactionScope(), S_OK);}
else
{
switch (m_lSupportedTxnDDL)
{
case DBPROPVAL_TC_DML:
//check for XACT_E_XTIONEXISTS
CHECK(hr = m_pTAdapter->InsideTransactionScope(), XACT_E_XTIONEXISTS);
break;
case DBPROPVAL_TC_DDL_IGNORE:
// the statement is not transacted
case DBPROPVAL_TC_ALL:
case DBPROPVAL_TC_DDL_COMMIT:
CHECK(hr = m_pTAdapter->InsideTransactionScope(), S_OK);
break;
case DBPROPVAL_TC_DDL_LOCK:
CHECK(hr = m_pTAdapter->InsideTransactionOnDDLLock(), S_OK);
break;
default:
TESTC(FALSE);
}
}
// end transaction
if (!fDDL || (DBPROPVAL_TC_DDL_COMMIT != m_lSupportedTxnDDL))
{
if (fAbortCommit)
{
CHECK(Abort(NULL, fRetaining, FALSE), S_OK);
}
else
{
CHECK(Commit(fRetaining, 0, 0), S_OK);
}
}
// check the result of the operation
if (
// DDL and aborted but prop is DDL ignore or DDL commit
( fDDL
&& ( (DBPROPVAL_TC_DDL_COMMIT == m_lSupportedTxnDDL)
|| (DBPROPVAL_TC_DDL_IGNORE == m_lSupportedTxnDDL))
//&& fAbortCommit // this is not necessary
)
// DDL and committed but prop is DML
|| ( fDDL
&& (DBPROPVAL_TC_DML == m_lSupportedTxnDDL)
//&& !fAbortCommit // this is not necessary
)
// operation is not a DDL and txn is committed
|| !fAbortCommit)
COMPARE(m_pTAdapter->CheckCompletion(), TRUE);
else
COMPARE(m_pTAdapter->CheckRollBack(), TRUE);
// end this transaction
CHECK(Commit(FALSE, 0, 0), fRetaining? S_OK: XACT_E_NOTRANSACTION);
CHECK(Abort(NULL, FALSE, FALSE), XACT_E_NOTRANSACTION);
CLEANUP:
CConsDesc::s_fInsideTransaction = FALSE;
TRETURN
} //CTransactionLocal::DoTransactionTest
Reference in New Issue View Git Blame Copy Permalink