able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/license/tlserver/jetblue/jetblue.cpp

3429 lines
74 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File:
//
// Contents:
//
// History:
//
//---------------------------------------------------------------------------
#include "JetBlue.h"
#include "locks.h"
#ifdef USE_SINGLE_JET_CALL
CCriticalSection g_JetCallLock;
#define SINGLE_JET_CALL CCriticalSectionLocker lock(g_JetCallLock)
#else
#define SINGLE_JET_CALL
#endif
DWORD
DeleteFilesInDirectory(
IN LPTSTR szDir,
IN LPTSTR szFilesToBeDelete,
IN BOOL bIncludeSubdir
)
/*++
--*/
{
TCHAR szFile[MAX_PATH+1];
HANDLE hFile;
WIN32_FIND_DATA findData;
BOOL bSuccess = TRUE;
DWORD dwStatus = ERROR_SUCCESS;
if (lstrlen(szDir) + lstrlen(szFilesToBeDelete) + 2 > sizeof(szFile) / sizeof(TCHAR))
{
return ERROR_INVALID_DATA;
}
wsprintf(
szFile,
_TEXT("%s\\%s"),
szDir,
szFilesToBeDelete
);
hFile = FindFirstFile(
szFile,
&findData
);
if(hFile == INVALID_HANDLE_VALUE)
{
return GetLastError();
}
// _tprintf(_TEXT("Deleting %s\n"), szDir);
while(bSuccess == TRUE)
{
if(findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY && bIncludeSubdir == TRUE)
{
if( lstrcmp(findData.cFileName, _TEXT(".")) != 0 &&
lstrcmp(findData.cFileName, _TEXT("..")) != 0 )
{
if (lstrlen(szDir) + lstrlen(findData.cFileName) + 2 <= sizeof(szFile) / sizeof(TCHAR))
{
wsprintf(szFile, _TEXT("%s\\%s"), szDir, findData.cFileName);
bSuccess = DeleteFilesInDirectory(
szFile,
szFilesToBeDelete,
bIncludeSubdir
);
}
}
}
else
{
if (lstrlen(szDir) + lstrlen(findData.cFileName) + 2 <= sizeof(szFile) / sizeof(TCHAR))
{
wsprintf(
szFile,
_TEXT("%s\\%s"),
szDir,
findData.cFileName
);
bSuccess = DeleteFile(szFile);
}
}
if(bSuccess == TRUE)
{
// return FALSE with error code set to ERROR_NO_MORE_FILES
bSuccess = FindNextFile(hFile, &findData);
}
}
dwStatus = GetLastError();
FindClose(hFile);
return (dwStatus == ERROR_NO_MORE_FILES) ? ERROR_SUCCESS : dwStatus;
}
//----------------------------------------------------------------
JET_ERR
ConvertTLSJbColumnDefToJbColumnCreate(
IN const PTLSJBColumn pTlsJbColumn,
IN OUT JET_COLUMNCREATE* pJetColumnCreate
)
/*
*/
{
pJetColumnCreate->cbStruct = sizeof(JET_COLUMNCREATE);
if(ConvertWstrToJBstr(pTlsJbColumn->pszColumnName, &pJetColumnCreate->szColumnName) == FALSE)
{
return JET_errInvalidParameter;
}
pJetColumnCreate->coltyp = pTlsJbColumn->colType;
pJetColumnCreate->cbMax = pTlsJbColumn->cbMaxLength;
pJetColumnCreate->grbit = pTlsJbColumn->jbGrbit;
pJetColumnCreate->pvDefault = pTlsJbColumn->pbDefValue;
pJetColumnCreate->cbDefault = pTlsJbColumn->cbDefValue;
pJetColumnCreate->cp = pTlsJbColumn->colCodePage;
return JET_errSuccess;
}
//----------------------------------------------------------------
JET_ERR
ConvertTlsJBTableIndexDefToJbIndexCreate(
IN const PTLSJBIndex pTlsJbTableIndex,
IN OUT JET_INDEXCREATE* pJetIndexCreate
)
/*
*/
{
JET_ERR jetError = JET_errSuccess;
DWORD count=0;
pJetIndexCreate->cbStruct = sizeof(JET_INDEXCREATE);
if(ConvertWstrToJBstr(pTlsJbTableIndex->pszIndexName, &pJetIndexCreate->szIndexName) == FALSE)
{
jetError = JET_errInvalidParameter;
goto cleanup;
}
if(pTlsJbTableIndex->pszIndexKey && pTlsJbTableIndex->cbKey == 0)
{
count++;
// need double NULL terminate
while(pTlsJbTableIndex->pszIndexKey[count] != _TEXT('\0') ||
pTlsJbTableIndex->pszIndexKey[count-1] != _TEXT('\0'))
{
//
// this max. is pseudo impose.
//
if(count >= TLS_JETBLUE_MAX_INDEXKEY_LENGTH)
{
jetError = JET_errInvalidParameter;
goto cleanup;
}
count++;
}
// pTlsJbTableIndex->cbKey = count;
}
else
{
count = pTlsJbTableIndex->cbKey;
}
if(ConvertMWstrToMJBstr(pTlsJbTableIndex->pszIndexKey, count, &pJetIndexCreate->szKey) == FALSE)
{
jetError = JET_errInvalidParameter;
goto cleanup;
}
pJetIndexCreate->cbKey = pTlsJbTableIndex->cbKey;
pJetIndexCreate->grbit = pTlsJbTableIndex->jbGrbit;
pJetIndexCreate->ulDensity = pTlsJbTableIndex->ulDensity;
cleanup:
return jetError;
}
//////////////////////////////////////////////////////////////////////
//
// JBInstance implementaion
//
//////////////////////////////////////////////////////////////////////
JBInstance::JBInstance() :
JBError(),
m_JetInstance(0),
m_bInit(FALSE),
m_NumSession(0)
{
}
//--------------------------------------------------------------------
JBInstance::~JBInstance()
{
if(m_bInit == FALSE)
{
return;
}
//JB_ASSERT(m_NumSession == 0);
//if(m_NumSession != 0)
//{
// throw JBError(JET_errTooManyActiveUsers);
//}
JBTerminate();
}
//--------------------------------------------------------------------
BOOL
JBInstance::JBInitJetInstance()
{
char szLogFilePath[MAX_PATH+1];
LPTSTR pszLogPath=NULL;
BOOL bSuccess;
if(m_bInit == TRUE)
{
SetLastJetError(JET_errAlreadyInitialized);
return FALSE;
}
SINGLE_JET_CALL;
m_JetErr = JetInit(&m_JetInstance);
if(m_JetErr == JET_errMissingLogFile)
{
//
// Delete log file and retry operation again
//
bSuccess = GetSystemParameter(
0,
JET_paramLogFilePath,
NULL,
(PBYTE)szLogFilePath,
sizeof(szLogFilePath)
);
if(bSuccess == TRUE && ConvertJBstrToWstr(szLogFilePath, &pszLogPath))
{
DeleteFilesInDirectory(
pszLogPath,
JETBLUE_RESLOG,
FALSE
);
DeleteFilesInDirectory(
pszLogPath,
JETBLUE_EDBLOG,
FALSE
);
m_JetErr = JetInit(&m_JetInstance);
}
}
m_bInit = IsSuccess();
return m_bInit;
}
//--------------------------------------------------------------------
BOOL
JBInstance::JBTerminate(
IN JET_GRBIT grbit,
IN BOOL bDeleteLogFile
)
{
char szLogFilePath[MAX_PATH+1];
LPTSTR pszLogPath=NULL;
BOOL bSuccess;
if(m_bInit == FALSE)
return TRUE;
//
// LSTESTER bug - one thread was still in enumeration while
// the other thread shutdown server
//
//if(m_NumSession > 0)
//{
// JB_ASSERT(m_NumSession == 0);
// SetLastJetError(JET_errTooManyActiveUsers);
// return FALSE;
//}
SINGLE_JET_CALL;
m_JetErr = JetTerm2(m_JetInstance, grbit);
// JB_ASSERT(m_JetErr == JET_errSuccess);
if(m_JetErr == JET_errSuccess && bDeleteLogFile == TRUE)
{
//
// Delete log file.
//
bSuccess = GetSystemParameter(
0,
JET_paramLogFilePath,
NULL,
(PBYTE)szLogFilePath,
sizeof(szLogFilePath)
);
if(bSuccess == TRUE && ConvertJBstrToWstr(szLogFilePath, &pszLogPath))
{
DeleteFilesInDirectory(
pszLogPath,
JETBLUE_RESLOG,
FALSE
);
DeleteFilesInDirectory(
pszLogPath,
JETBLUE_EDBLOG,
FALSE
);
}
}
m_bInit = FALSE;
// need to add operator= to this class.
// m_NumSession = 0; // force terminate.
if(pszLogPath != NULL)
{
LocalFree(pszLogPath);
}
return (m_JetErr == JET_errSuccess);
}
//--------------------------------------------------------------------
BOOL
JBInstance::SetSystemParameter(
IN JET_SESID SesId,
IN unsigned long lParamId,
IN ULONG_PTR lParam,
IN PBYTE sz
)
{
LPSTR lpszParm=NULL;
if(lParamId == JET_paramSystemPath ||
lParamId == JET_paramTempPath ||
lParamId == JET_paramLogFilePath )
{
if(ConvertWstrToJBstr((LPTSTR)sz, &lpszParm) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
return FALSE;
}
}
else
{
lpszParm = (LPSTR)sz;
}
SINGLE_JET_CALL;
m_JetErr = JetSetSystemParameter(
&m_JetInstance,
SesId,
lParamId,
lParam,
(const char *)lpszParm
);
if(lParamId == JET_paramSystemPath || lParamId == JET_paramTempPath ||
lParamId == JET_paramLogFilePath )
{
FreeJBstr(lpszParm);
}
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBInstance::GetSystemParameter(
IN JET_SESID SesId,
IN unsigned long lParamId,
IN ULONG_PTR* plParam,
IN PBYTE sz,
IN unsigned long cbMax
)
{
SINGLE_JET_CALL;
m_JetErr = JetGetSystemParameter(
m_JetInstance,
SesId,
lParamId,
plParam,
(char *)sz,
cbMax
);
return IsSuccess();
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_SESID
JBInstance::BeginJetSession(
IN LPCTSTR pszUserName,
IN LPCTSTR pszPwd
)
{
JET_SESID sesId = JET_sesidNil;
LPSTR lpszUserName=NULL;
LPSTR lpszPwd=NULL;
if(m_bInit == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return JET_sesidNil;
}
if(ConvertWstrToJBstr(pszUserName, &lpszUserName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
if(ConvertWstrToJBstr(pszPwd, &lpszPwd) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetBeginSession(
m_JetInstance,
&sesId,
lpszUserName,
lpszPwd
);
}
if(IsSuccess() == TRUE)
{
m_NumSession++;
}
cleanup:
FreeJBstr(lpszUserName);
FreeJBstr(lpszPwd);
return IsSuccess() ? sesId : JET_sesidNil;
}
//--------------------------------------------------------------------
CLASS_PRIVATE BOOL
JBInstance::EndJetSession(
IN JET_SESID JetSessionID,
IN JET_GRBIT grbit
)
{
SINGLE_JET_CALL;
m_JetErr = JetEndSession(JetSessionID, grbit);
if(IsSuccess() == TRUE)
{
m_NumSession--;
}
return IsSuccess();
}
//--------------------------------------------------------------------
CLASS_PRIVATE BOOL
JBInstance::EndSession(
IN JET_SESID sesId,
IN JET_GRBIT grbit
)
{
return EndJetSession( sesId, grbit );
}
//----------------------------------------------------------------------------
// Implementation for JBSession
//----------------------------------------------------------------------------
JBSession::JBSession(
IN JBInstance& JetInstance,
IN JET_SESID JetSessID
) :
JBError(),
m_JetInstance(JetInstance),
m_JetSessionID(JetSessID),
m_TransactionLevel(0),
m_JetDBInitialized(0)
/*
*/
{
}
//-----------------------------------------------------------
JBSession::JBSession(
IN JBSession& JetSession
) :
JBError(),
m_JetInstance(JetSession.GetJetInstance()),
m_JetSessionID(JET_sesidNil),
m_TransactionLevel(0),
m_JetDBInitialized(0)
{
if(DuplicateSession(JetSession.GetJetSessionID()) == FALSE)
{
JB_ASSERT(FALSE);
throw JBError(GetLastJetError());
}
}
//-----------------------------------------------------------
JBSession::~JBSession()
/*
*/
{
if(IsValid() == TRUE && EndSession() == FALSE)
{
// do nothing, license server uses only global instance
// JB_ASSERT(FALSE);
// throw JBError(GetLastJetError());
}
}
//----------------------------------------------------------
CLASS_PRIVATE BOOL
JBSession::DuplicateSession(
IN JET_SESID sessID
)
{
SINGLE_JET_CALL;
m_JetErr = JetDupSession(sessID, &m_JetSessionID);
return IsSuccess();
}
//----------------------------------------------------------
CLASS_PRIVATE JET_DBID
JBSession::OpenJetDatabase(
IN LPCTSTR pszFile,
IN LPCTSTR pszConnect,
IN JET_GRBIT grbit
)
{
JET_DBID jdbId = JET_dbidNil;
LPSTR lpszFile=NULL;
LPSTR lpszConnect=NULL;
if(ConvertWstrToJBstr(pszFile, &lpszFile) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
if(ConvertWstrToJBstr(pszConnect, &lpszConnect) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
if(AttachDatabase(pszFile, grbit) == FALSE)
goto cleanup;
{
SINGLE_JET_CALL;
m_JetErr = JetOpenDatabase(
m_JetSessionID,
lpszFile,
lpszConnect,
&jdbId,
grbit
);
}
if(IsSuccess() == TRUE)
{
m_JetDBInitialized++;
}
cleanup:
FreeJBstr(lpszFile);
FreeJBstr(lpszConnect);
return IsSuccess() ? jdbId : JET_dbidNil;
}
//----------------------------------------------------------
CLASS_PRIVATE BOOL
JBSession::CloseJetDatabase(
IN JET_DBID jdbId,
IN JET_GRBIT grbit
)
{
SINGLE_JET_CALL;
m_JetErr = JetCloseDatabase(
m_JetSessionID,
jdbId,
grbit
);
if(IsSuccess() == TRUE)
{
m_JetDBInitialized--;
}
return (IsSuccess());
}
//----------------------------------------------------------
CLASS_PRIVATE JET_DBID
JBSession::CreateJetDatabase(
IN LPCTSTR pszFile,
IN LPCTSTR pszConnect,
IN JET_GRBIT grbit
)
{
JET_DBID jdbId = JET_dbidNil;
LPSTR lpszFile=NULL;
LPSTR lpszConnect=NULL;
if(ConvertWstrToJBstr(pszFile, &lpszFile) == FALSE)
{
SetLastError(JET_errInvalidParameter);
goto cleanup;
}
if(ConvertWstrToJBstr(pszConnect, &lpszConnect) == FALSE)
{
SetLastError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetCreateDatabase(
m_JetSessionID,
lpszFile,
lpszConnect,
&jdbId,
grbit
);
}
if(IsSuccess() == TRUE)
{
m_JetDBInitialized++;
}
cleanup:
FreeJBstr(lpszFile);
FreeJBstr(lpszConnect);
return IsSuccess() ? jdbId : JET_dbidNil;
}
//----------------------------------------------------------
BOOL
JBSession::BeginSession(
IN LPCTSTR pszUserName,
IN LPCTSTR pszPwd
)
/*
*/
{
BOOL bSuccess;
if(m_JetInstance.IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
if(m_JetSessionID != JET_sesidNil)
{
SetLastJetError(JET_errAlreadyInitialized);
return FALSE;
}
m_JetSessionID = m_JetInstance.BeginJetSession(
pszUserName,
pszPwd
);
if(m_JetSessionID == JET_sesidNil)
{
m_JetErr = m_JetInstance.GetLastJetError();
}
return IsSuccess();
}
//----------------------------------------------------------
BOOL
JBSession::EndSession(
IN JET_GRBIT grbit /* JET_bitTermComplete */
)
/*
*/
{
BOOL bSuccess;
if(GetTransactionLevel() != 0)
{
//
// Terminate existing transaction
//
bSuccess = EndAllTransaction(FALSE);
if(bSuccess == FALSE)
{
JB_ASSERT(FALSE);
SetLastJetError(JET_errTransTooDeep);
return FALSE;
}
}
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
if(m_JetDBInitialized > 0)
{
JB_ASSERT(m_JetDBInitialized);
SetLastJetError(JET_errTooManyActiveUsers);
return FALSE;
}
//
// Huei - routine to be phrased out ?
//
bSuccess=m_JetInstance.EndSession(
m_JetSessionID,
grbit
);
if(bSuccess == TRUE)
{
m_JetSessionID = JET_sesidNil;
}
else
{
m_JetErr = m_JetInstance.GetLastJetError();
}
return IsSuccess();
}
//------------------------------------------------------------
BOOL
JBSession::SetSystemParameter(
IN unsigned long lParamId,
IN ULONG_PTR lParam,
IN const PBYTE sz
)
{
BOOL bSuccess;
bSuccess = m_JetInstance.SetSystemParameter(
m_JetSessionID,
lParamId,
lParam,
sz
);
if(bSuccess == FALSE)
{
m_JetErr = m_JetInstance.GetLastJetError();
}
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::GetSystemParameter(
IN unsigned long lParamId,
IN ULONG_PTR* plParam,
IN PBYTE sz,
IN unsigned long cbMax
)
{
BOOL bSuccess;
bSuccess = m_JetInstance.GetSystemParameter(
m_JetSessionID,
lParamId,
plParam,
sz,
cbMax
);
if(bSuccess == FALSE)
{
m_JetErr = m_JetInstance.GetLastJetError();
}
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::AttachDatabase(
IN LPCTSTR pszFileName,
IN JET_GRBIT grbit
)
{
LPSTR lpszFileName=NULL;
if(m_JetSessionID == JET_sesidNil)
{
SetLastJetError(JET_errNotInitialized);
goto cleanup;
}
if(ConvertWstrToJBstr(pszFileName, &lpszFileName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetAttachDatabase(
m_JetSessionID,
lpszFileName,
grbit
);
}
cleanup:
FreeJBstr(lpszFileName);
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::DetachDatabase(
IN LPCTSTR pszFileName
)
{
LPSTR lpszFileName = NULL;
if(m_JetSessionID == JET_sesidNil)
{
SetLastJetError(JET_errNotInitialized);
goto cleanup;
}
if(ConvertWstrToJBstr(pszFileName, &lpszFileName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetDetachDatabase(
m_JetSessionID,
lpszFileName
);
}
cleanup:
FreeJBstr(lpszFileName);
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::BeginTransaction()
{
if(m_JetSessionID == JET_sesidNil)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
SINGLE_JET_CALL;
m_JetErr = JetBeginTransaction(
m_JetSessionID
);
if(IsSuccess() == TRUE)
{
m_TransactionLevel++;
}
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::CommitTransaction(
IN JET_GRBIT grbit
)
{
if(m_JetSessionID == JET_sesidNil)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
SINGLE_JET_CALL;
m_JetErr = JetCommitTransaction(
m_JetSessionID,
grbit
);
if(IsSuccess() == TRUE)
{
m_TransactionLevel --;
}
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::RollbackTransaction(
IN JET_GRBIT grbit
)
{
if(m_JetSessionID == JET_sesidNil)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
SINGLE_JET_CALL;
m_JetErr = JetRollback(
m_JetSessionID,
grbit
);
if(IsSuccess() == TRUE)
m_TransactionLevel--;
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBSession::EndAllTransaction(
IN BOOL bCommit,
IN JET_GRBIT grbit
)
{
BOOL bEnd = TRUE;
while(m_TransactionLevel > 0 && bEnd == TRUE)
{
bEnd = (bCommit == TRUE) ?
CommitTransaction(grbit) : RollbackTransaction(grbit);
}
return bEnd;
}
//--------------------------------------------------------------------
CLASS_PRIVATE BOOL
JBSession::CloseDatabase(
JET_DBID jdbId,
JET_GRBIT grbit
)
{
return CloseJetDatabase(jdbId, grbit);
}
//////////////////////////////////////////////////////////////////////
//
// JBDatabase
//
//////////////////////////////////////////////////////////////////////
JBDatabase::JBDatabase(
IN JBSession& jbSession,
IN JET_DBID jdbId, /* JET_dbidNil */
IN LPCTSTR pszDatabase // NULL
) :
JBError(),
m_JetSession(jbSession),
m_JetDbId(jdbId),
m_TableOpened(0)
/*
*/
{
if(pszDatabase)
{
_tcscpy(m_szDatabaseFile, pszDatabase);
}
else
{
memset(m_szDatabaseFile, 0, sizeof(m_szDatabaseFile));
}
}
//--------------------------------------------------------------------
JBDatabase::~JBDatabase()
{
if(CloseDatabase() == FALSE)
{
// do nothing, license server uses only global instance.
// JB_ASSERT(FALSE);
// throw JBError(GetLastJetError());
}
}
//--------------------------------------------------------------------
BOOL
JBDatabase::CloseDatabase(
IN JET_GRBIT grbit
)
{
BOOL bSuccess;
//
// Verify we have properly initialized
//
if(IsValid() == FALSE)
return TRUE;
//
// No table is still opened from the DB ID
//
if(m_TableOpened > 0)
{
JB_ASSERT(FALSE);
SetLastJetError(JET_errTooManyActiveUsers);
return FALSE;
}
//
// Close the database
//
bSuccess = m_JetSession.CloseJetDatabase(
m_JetDbId,
grbit
);
if(bSuccess == FALSE || m_JetSession.DetachDatabase(m_szDatabaseFile) == FALSE)
{
m_JetErr = m_JetSession.GetLastJetError();
}
else
{
m_JetDbId = JET_dbidNil;
memset(m_szDatabaseFile, 0, sizeof(m_szDatabaseFile));
}
return IsSuccess();
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_TABLEID
JBDatabase::OpenJetTable(
IN LPCTSTR pszTableName,
IN void* pvParam, // NULL
IN unsigned long cbParam, // 0
JET_GRBIT grbit // JET_bitTableUpdatable
)
/*
*/
{
LPSTR lpszTableName = NULL;
JET_TABLEID tableid = JET_tableidNil;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
if(ConvertWstrToJBstr(pszTableName, &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr=JetOpenTable(
m_JetSession.GetJetSessionID(),
m_JetDbId,
lpszTableName,
pvParam,
cbParam,
grbit,
&tableid
);
}
if(IsSuccess() == TRUE)
{
m_TableOpened++;
}
cleanup:
FreeJBstr(lpszTableName);
return tableid;
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_TABLEID
JBDatabase::DuplicateJetCursor(
// IN JET_SESID sesId,
IN JET_TABLEID srcTableid,
IN JET_GRBIT grbit
)
/*
*/
{
JET_TABLEID tableid = JET_tableidNil;
SINGLE_JET_CALL;
m_JetErr = JetDupCursor(
GetJetSessionID(),
srcTableid,
&tableid,
0 // grbit must be zero
);
if(IsSuccess() == TRUE)
{
m_TableOpened++;
}
return (IsSuccess() == TRUE) ? tableid : JET_tableidNil;
}
//--------------------------------------------------------------------
CLASS_PRIVATE BOOL
JBDatabase::CloseJetTable(
// IN JET_SESID sesId,
IN JET_TABLEID tableid
)
/*
*/
{
// JetBlue AC with empty table
SINGLE_JET_CALL;
try {
m_JetErr = JetCloseTable(
GetJetSessionID(),
tableid
);
}
catch(...) {
m_JetErr = JET_errSuccess;
}
if(IsSuccess())
{
m_TableOpened--;
}
return IsSuccess();
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_TABLEID
JBDatabase::CreateJetTable(
LPCTSTR pszTableName,
unsigned long lPage, // 0
unsigned long lDensity // 20
)
/*
*/
{
JET_TABLEID tableid = JET_tableidNil;
JB_STRING lpszTableName=NULL;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
goto cleanup;
}
if(ConvertWstrToJBstr(pszTableName, &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetCreateTable(
GetJetSessionID(),
m_JetDbId,
lpszTableName,
lPage,
lDensity,
&tableid
);
}
if(IsSuccess() == FALSE)
{
goto cleanup;
}
m_TableOpened++;
cleanup:
FreeJBstr(lpszTableName);
return tableid;
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_TABLEID
JBDatabase::CreateJetTableEx(
LPCTSTR pszTableName,
const PTLSJBTable table_attribute,
const PTLSJBColumn columns,
const DWORD num_columns,
const PTLSJBIndex table_index,
const DWORD num_table_index
)
/*
*/
{
JET_TABLEID tableid = JET_tableidNil;
JB_STRING lpszTableName=NULL;
JET_TABLECREATE table_create;
JET_COLUMNCREATE* column_create=NULL;
JET_INDEXCREATE* index_create=NULL;
DWORD index=0;
SINGLE_JET_CALL;
table_create.szTableName = NULL;
table_create.szTemplateTableName = NULL;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
goto cleanup;
}
if(ConvertWstrToJBstr(pszTableName, &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
table_create.cbStruct = sizeof(JET_TABLECREATE);
table_create.szTableName = lpszTableName;
if(ConvertWstrToJBstr(table_attribute->pszTemplateTableName, &table_create.szTemplateTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
table_create.ulPages = table_attribute->ulPages;
table_create.ulDensity = (table_attribute->ulDensity < 20 || table_attribute->ulDensity > 100) ?
TLS_JETBLUE_DEFAULT_TABLE_DENSITY : table_attribute->ulDensity;
table_create.grbit = table_attribute->jbGrbit;
//
// form a JET_TABLECREATE structure
//
column_create = (JET_COLUMNCREATE *)AllocateMemory(
sizeof(JET_COLUMNCREATE) * num_columns
);
if(column_create == NULL)
{
SetLastJetError(JET_errOutOfMemory);
goto cleanup;
}
index_create = (JET_INDEXCREATE *)AllocateMemory(
sizeof(JET_INDEXCREATE) * num_table_index
);
if(index_create == NULL)
{
SetLastJetError(JET_errOutOfMemory);
goto cleanup;
}
for(index=0; index < num_columns; index++)
{
if(ConvertTLSJbColumnDefToJbColumnCreate( columns+index, column_create+index ) == FALSE)
{
goto cleanup;
}
}
for(index=0; index < num_table_index; index++)
{
if(ConvertTlsJBTableIndexDefToJbIndexCreate( table_index+index, index_create+index ) == FALSE)
goto cleanup;
}
table_create.rgcolumncreate = column_create;
table_create.cColumns = num_columns;
table_create.rgindexcreate = index_create;
table_create.cIndexes = num_table_index;
m_JetErr = JetCreateTableColumnIndex(
GetJetSessionID(),
GetJetDatabaseID(),
&table_create
);
if(IsSuccess() == TRUE)
{
tableid = table_create.tableid;
}
cleanup:
if(column_create != NULL)
{
for(index=0; index < num_columns; index++)
{
if(column_create[index].szColumnName != NULL)
{
FreeJBstr(column_create[index].szColumnName);
}
}
FreeMemory(column_create);
}
if(index_create != NULL)
{
for(index=0; index < num_table_index; index++)
{
if(index_create[index].szIndexName != NULL)
{
FreeJBstr(index_create[index].szIndexName);
}
if(index_create[index].szKey != NULL)
{
FreeJBstr(index_create[index].szKey);
}
}
FreeMemory(index_create);
}
if(table_create.szTemplateTableName)
FreeJBstr(table_create.szTemplateTableName);
if(table_create.szTableName)
FreeJBstr(table_create.szTableName);
return tableid;
}
//--------------------------------------------------------------------
JET_TABLEID
JBDatabase::CreateTable(
LPCTSTR pszTableName,
unsigned long lPage, // 0
unsigned long lDensity // 20
)
/*
*/
{
JET_TABLEID tableid;
tableid = CreateJetTable(
pszTableName,
lPage,
lDensity
);
if(tableid == JET_tableidNil)
{
m_JetErr = GetLastJetError();
}
return tableid;
}
//-------------------------------------------------------------------
JET_TABLEID
JBDatabase::CreateTableEx(
LPCTSTR pszTableName,
const PTLSJBTable table_attribute,
const PTLSJBColumn columns,
DWORD num_columns,
const PTLSJBIndex index,
DWORD num_index
)
/*
*/
{
JET_TABLEID tableid;
tableid = CreateJetTableEx(
pszTableName,
table_attribute,
columns,
num_columns,
index,
num_index
);
if(tableid == JET_tableidNil)
{
m_JetErr = GetLastJetError();
}
return tableid;
}
//--------------------------------------------------------------------
CLASS_PRIVATE BOOL
JBDatabase::CloseTable(
JET_TABLEID tableid
)
/*
? Verify this table ID is from this DB/Session
*/
{
return CloseJetTable( tableid );
}
//--------------------------------------------------------------------
BOOL
JBDatabase::DeleteTable(
IN LPCTSTR pszTableName
)
/*
TODO - ? verify this table is in this database
*/
{
JB_STRING lpszTableName=NULL;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
goto cleanup;
}
if(ConvertWstrToJBstr(pszTableName, &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetDeleteTable(
GetJetSessionID(),
GetJetDatabaseID(),
lpszTableName
);
}
//if(IsSuccess() == FALSE)
// goto cleanup;
cleanup:
FreeJBstr(lpszTableName);
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBDatabase::OpenDatabase(
LPCTSTR szFile,
LPCTSTR szConnect, // NULL
JET_GRBIT grbit // 0
)
/*
*/
{
m_JetDbId = m_JetSession.OpenJetDatabase(
szFile,
szConnect,
grbit
);
if(m_JetDbId == JET_dbidNil)
{
m_JetErr = m_JetSession.GetLastJetError();
}
else
{
_tcscpy(m_szDatabaseFile, szFile);
}
return m_JetDbId != JET_dbidNil;
}
//--------------------------------------------------------------------
BOOL
JBDatabase::CreateDatabase(
LPCTSTR szFile,
LPCTSTR szConnect, // NULL
JET_GRBIT grbit // 0
)
/*
*/
{
m_JetDbId = m_JetSession.CreateJetDatabase(
szFile,
szConnect,
grbit
);
if(m_JetDbId == JET_dbidNil)
{
m_JetErr = m_JetSession.GetLastJetError();
}
else
{
_tcscpy(m_szDatabaseFile, szFile);
}
return m_JetDbId != JET_dbidNil;
}
//////////////////////////////////////////////////////////////////////
//
// JBTable
//
//////////////////////////////////////////////////////////////////////
JBColumn JBTable::m_ErrColumn;
JBTable::JBTable(
JBDatabase& JetDatabase,
LPCTSTR pszTableName,
JET_TABLEID tableid
) :
JBError(),
m_JetDatabase(JetDatabase),
m_JetTableId(tableid),
m_JetColumns(NULL),
m_NumJetColumns(0),
m_InEnumeration(FALSE),
m_InsertRepositionBookmark(FALSE)
/*
*/
{
if(pszTableName)
{
_tcscpy(m_szTableName, pszTableName);
}
else
{
memset(m_szTableName, 0, sizeof(m_szTableName));
}
}
//--------------------------------------------------------------------
JBTable::JBTable(
JBTable& jbTable
) :
JBError(),
m_JetDatabase(jbTable.GetJetDatabase()),
m_JetColumns(NULL),
m_NumJetColumns(0),
m_InEnumeration(FALSE)
/*
*/
{
// duplicate jet cursor
_tcscpy(m_szTableName, jbTable.GetTableName());
m_JetTableId = m_JetDatabase.DuplicateJetCursor(
jbTable.GetJetTableID(),
0
);
if(m_JetTableId == JET_tableidNil)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
}
//--------------------------------------------------------------------
JBTable::~JBTable()
{
if(m_JetTableId == JET_tableidNil)
return;
CloseTable();
}
//--------------------------------------------------------------------
CLASS_PRIVATE JET_COLUMNID
JBTable::AddJetColumn(
LPCTSTR pszColumnName,
const JET_COLUMNDEF* pColumnDef,
const PVOID pbDefaultValue, // NULL
const unsigned long cbDefaultValue // 0
)
/*
*/
{
DebugOutput(
_TEXT("Adding column %s to table %s, type %d\n"),
pszColumnName,
GetTableName(),
pColumnDef->coltyp
);
JB_STRING lpszColumnName=NULL;
JET_COLUMNID columnid = (DWORD)JET_NIL_COLUMN;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
if(ConvertWstrToJBstr(pszColumnName, &lpszColumnName) == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetAddColumn(
GetJetSessionID(),
GetJetTableID(),
lpszColumnName,
pColumnDef,
pbDefaultValue,
cbDefaultValue,
&columnid
);
}
cleanup:
DebugOutput(
_TEXT("AddJetColumn returns %d\n"),
GetLastJetError()
);
FreeJBstr(lpszColumnName);
return columnid;
}
//--------------------------------------------------------------------
BOOL
JBTable::AddIndex(
JBKeyBase* key
)
/*
*/
{
return AddJetIndex(
key->GetIndexName(),
key->GetIndexKey(),
key->GetKeyLength(),
key->GetJetGrbit(),
key->GetJetDensity()
);
}
//--------------------------------------------------------------------
BOOL
JBTable::AddJetIndex(
LPCTSTR pszIndexName,
LPCTSTR pszKey,
unsigned long cbKey,
JET_GRBIT grbit, /* 0 */
unsigned long lDensity /* 20 */
)
/*
*/
{
DebugOutput(
_TEXT("Adding Index %s to table %s\n"),
pszIndexName,
GetTableName()
);
JB_STRING lpszIndexName=NULL;
JB_STRING lpszKeyName=NULL;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
if(ConvertWstrToJBstr(pszIndexName, &lpszIndexName) == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
if(ConvertMWstrToMJBstr(pszKey, cbKey, &lpszKeyName) == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetCreateIndex(
GetJetSessionID(),
GetJetTableID(),
lpszIndexName,
grbit,
lpszKeyName,
cbKey,
lDensity
);
}
cleanup:
DebugOutput(
_TEXT("Adding index %s returns %d\n"),
pszIndexName,
GetLastJetError()
);
FreeJBstr(lpszIndexName);
FreeJBstr(lpszKeyName);
return IsSuccess();
}
BOOL
JBTable::DoesIndexExist(
LPCTSTR pszIndexName
)
{
JB_STRING lpszIndexName=NULL;
JET_INDEXID idx;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
if(ConvertWstrToJBstr(pszIndexName, &lpszIndexName) == FALSE)
{
SetLastJetError(JET_errInvalidDatabaseId);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetGetTableIndexInfo(
GetJetSessionID(),
GetJetTableID(),
lpszIndexName,
&idx,
sizeof(JET_INDEXID),
JET_IdxInfoIndexId
);
// if this succeeds, the index exists
}
cleanup:
FreeJBstr(lpszIndexName);
return IsSuccess();
}
//--------------------------------------------------------------------
BOOL
JBTable::CloseTable()
{
BOOL bSuccess;
if(m_JetTableId == JET_tableidNil)
return TRUE;
bSuccess = m_JetDatabase.CloseTable(
m_JetTableId
);
if(bSuccess == FALSE)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
//
// Force close on table.
//
m_JetTableId = JET_tableidNil;
if(m_JetColumns)
delete [] m_JetColumns;
m_JetColumns = NULL;
m_NumJetColumns = 0;
return bSuccess;
}
//--------------------------------------------------------------------
BOOL
JBTable::CreateOpenTable(
IN LPCTSTR pszTableName,
IN unsigned long lPage, // 0
IN unsigned long lDensity // 20
)
/*
*/
{
if(m_JetTableId != JET_tableidNil)
{
SetLastJetError(JET_errInvalidParameter);
return FALSE;
}
DebugOutput(
_TEXT("Creating Table %s\n"),
pszTableName
);
m_JetTableId = m_JetDatabase.CreateJetTable(
pszTableName,
lPage,
lDensity
);
if(m_JetTableId == JET_tableidNil)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
return (m_JetTableId != JET_tableidNil);
}
//--------------------------------------------------------------------
BOOL
JBTable::OpenTable(
IN LPCTSTR pszTableName,
IN void* pvParam,
IN unsigned long cbParam,
IN JET_GRBIT grbit
)
/*
*/
{
DebugOutput(
_TEXT("Opening table %s\n"),
pszTableName
);
JB_ASSERT(m_JetTableId == JET_tableidNil);
if(m_JetTableId != JET_tableidNil)
{
SetLastJetError(JET_errTableInUse);
return FALSE;
}
m_JetTableId = m_JetDatabase.OpenJetTable(
pszTableName,
pvParam,
cbParam,
grbit
);
if(m_JetTableId == JET_tableidNil)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
else
{
// load column info in the table
_tcscpy(m_szTableName, pszTableName);
if(LoadTableInfo() == FALSE)
{
// force a close on table
CloseTable();
}
}
DebugOutput(
_TEXT("Open table %s return code %d\n"),
pszTableName,
GetLastJetError()
);
return (m_JetTableId != JET_tableidNil);
}
//--------------------------------------------------------------------
JBTable*
JBTable::DuplicateCursor(
JET_GRBIT grbit /* 0 */
)
/*
*/
{
JET_TABLEID tableid;
tableid = m_JetDatabase.DuplicateJetCursor(
m_JetTableId,
grbit
);
if(tableid == JET_tableidNil)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
return new JBTable(
m_JetDatabase,
GetTableName(),
tableid
);
}
//--------------------------------------------------------------------
JBTable&
JBTable::operator=(const JBTable& srcTable)
{
if(this == &srcTable)
return *this;
// database has to be the same
// verify database is consistent
_tcscpy(m_szTableName, srcTable.GetTableName());
m_JetTableId = m_JetDatabase.DuplicateJetCursor(
srcTable.GetJetTableID(),
0
);
if(m_JetTableId == JET_tableidNil)
{
m_JetErr = m_JetDatabase.GetLastJetError();
}
return *this;
}
//--------------------------------------------------------------------
int
JBTable::AddColumn(
int numColumns,
PTLSJBColumn pColumnDef
)
/*
*/
{
JET_COLUMNDEF column;
JET_COLUMNID jet_columnid;
for(int i=0; i < numColumns; i++)
{
memset(&column, 0, sizeof(column));
column.cbStruct = sizeof(JET_COLUMNDEF);
column.coltyp = (pColumnDef+i)->colType;
column.wCountry = (pColumnDef+i)->wCountry;
column.langid = (pColumnDef+i)->langid;
column.cp = (pColumnDef+i)->colCodePage;
column.cbMax = (pColumnDef+i)->cbMaxLength;
column.grbit = (pColumnDef+i)->jbGrbit;
jet_columnid = AddJetColumn(
(pColumnDef+i)->pszColumnName,
&column,
(pColumnDef+i)->pbDefValue,
(pColumnDef+i)->cbDefValue
);
if(jet_columnid == JET_NIL_COLUMN)
break;
}
// return which column cause trouble
return i;
}
//--------------------------------------------------------------------
int
JBTable::AddIndex(
int numIndex,
PTLSJBIndex pIndex
)
/*
*/
{
unsigned long keylength;
for(int i=0; i < numIndex; i++)
{
if((pIndex+i)->cbKey == -1)
{
// calculate index key length
keylength = 2;
while((pIndex+i)->pszIndexKey[keylength-1] != _TEXT('\0') ||
(pIndex+i)->pszIndexKey[keylength-2] != _TEXT('\0'))
{
if(keylength >= TLS_JETBLUE_MAX_INDEXKEY_LENGTH)
{
SetLastJetError(JET_errInvalidParameter);
break;
}
keylength++;
}
}
else
{
keylength = (pIndex+i)->cbKey;
}
if(keylength >= TLS_JETBLUE_MAX_INDEXKEY_LENGTH)
{
SetLastJetError(JET_errInvalidParameter);
break;
}
if(AddJetIndex(
(pIndex+i)->pszIndexName,
(pIndex+i)->pszIndexKey,
keylength,
(pIndex+i)->jbGrbit,
(pIndex+i)->ulDensity
) == FALSE)
{
break;
}
}
return (i >= numIndex) ? 0 : i;
}
//-------------------------------------------------------------
CLASS_PRIVATE BOOL
JBTable::LoadTableInfo()
/*
*/
{
#if 1
LPSTR lpszTableName=NULL;
JET_COLUMNLIST columns;
unsigned long cbMax;
JET_RETINFO jetRetInfo;
char lpszColumnName[MAX_JETBLUE_NAME_LENGTH+1];
int NumChars;
unsigned long index;
SINGLE_JET_CALL;
if(ConvertWstrToJBstr(GetTableName(), &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
memset(&columns, 0, sizeof(columns));
columns.cbStruct = sizeof(JET_COLUMNLIST);
cbMax = sizeof(JET_COLUMNLIST);
m_JetErr = JetGetColumnInfo(
GetJetSessionID(),
GetJetDatabaseID(),
lpszTableName,
NULL,
(PVOID)&columns,
cbMax,
1 // retrieve column list
);
if(IsSuccess() == FALSE)
goto cleanup;
//
// Table has just been created
//
if(columns.cRecord == 0)
goto cleanup;
m_JetColumns = new JBColumn[columns.cRecord];
if(m_JetColumns == NULL)
{
SetLastJetError(JET_errOutOfMemory);
goto cleanup;
}
SetLastJetError(JET_errSuccess);
//
// TODO - use JBColumn class to retrieve value
//
m_NumJetColumns = columns.cRecord;
for(index=0;
index < columns.cRecord && IsSuccess() == TRUE;
index++)
{
m_JetColumns[index].AttachToTable(this);
if(m_JetColumns[index].LoadJetColumnInfoFromJet(&columns) == FALSE)
{
m_JetErr = m_JetColumns[index].GetLastJetError();
break;
}
m_JetErr = JetMove(
GetJetSessionID(),
columns.tableid,
JET_MoveNext,
0
);
}
if(GetLastJetError() == JET_errNoCurrentRecord && index >= columns.cRecord)
{
// otherwise - got to be a JetBlue bug here.
SetLastJetError(JET_errSuccess);
}
//
//
//
cleanup:
FreeJBstr(lpszTableName);
if(IsSuccess() == FALSE && m_JetColumns)
{
delete [] m_JetColumns;
m_JetColumns = NULL;
m_NumJetColumns = 0;
}
return IsSuccess();
#else
LPSTR lpszTableName=NULL;
JET_COLUMNLIST columns;
unsigned long cbMax;
JET_RETINFO jetRetInfo;
unsigned long cbActual;
char lpszColumnName[MAX_JETBLUE_NAME_LENGTH+1];
int NumChars;
unsigned long index;
SINGLE_JET_CALL;
if(ConvertWstrToJBstr(GetTableName(), &lpszTableName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
memset(&columns, 0, sizeof(columns));
columns.cbStruct = sizeof(JET_COLUMNLIST);
cbMax = sizeof(JET_COLUMNLIST);
m_JetErr = JetGetColumnInfo(
GetJetSessionID(),
GetJetDatabaseID(),
lpszTableName,
NULL,
(PVOID)&columns,
cbMax,
1 // retrieve column list
);
if(IsSuccess() == FALSE)
goto cleanup;
//
// Table has just been created
//
if(columns.cRecord == 0)
goto cleanup;
// retrieve column name, column id, column type and column size
m_Columns = (PJetColumns) AllocateMemory(sizeof(JetColumns) * columns.cRecord);
if(m_Columns == NULL)
{
SetLastJetError(JET_errOutOfMemory);
goto cleanup;
}
SetLastJetError(JET_errSuccess);
//
// TODO - use JBColumn class to retrieve value
//
m_NumColumns = columns.cRecord;
for(index=0;
index < columns.cRecord && IsSuccess() == TRUE;
index++)
{
memset(&jetRetInfo, 0, sizeof(JET_RETINFO));
jetRetInfo.cbStruct = sizeof(JET_RETINFO);
// retrieve column name
m_JetErr = JetRetrieveColumn(
GetJetSessionID(),
columns.tableid,
columns.columnidcolumnname,
lpszColumnName,
sizeof(lpszColumnName),
&cbActual,
0,
&jetRetInfo
);
if(IsSuccess() == FALSE)
continue;
NumChars = MultiByteToWideChar(
GetACP(),
MB_PRECOMPOSED,
lpszColumnName,
cbActual,
(m_Columns+index)->pszColumnName,
sizeof((m_Columns+index)->pszColumnName)
);
if(NumChars == 0)
{
SetLastJetError(JET_errInvalidParameter);
continue;
}
memset(&jetRetInfo, 0, sizeof(JET_RETINFO));
jetRetInfo.cbStruct = sizeof(JET_RETINFO);
// retrieve column ID
m_JetErr = JetRetrieveColumn(
GetJetSessionID(),
columns.tableid,
columns.columnidcolumnid,
&((m_Columns+index)->colId),
sizeof((m_Columns+index)->colId),
&cbActual,
0,
&jetRetInfo
);
if(IsSuccess() == FALSE)
continue;
memset(&jetRetInfo, 0, sizeof(JET_RETINFO));
jetRetInfo.cbStruct = sizeof(JET_RETINFO);
m_JetErr = JetRetrieveColumn(
GetJetSessionID(),
columns.tableid,
columns.columnidcoltyp,
&((m_Columns+index)->colType),
sizeof((m_Columns+index)->colType),
&cbActual,
0,
&jetRetInfo
);
if(IsSuccess() == FALSE)
continue;
memset(&jetRetInfo, 0, sizeof(JET_RETINFO));
jetRetInfo.cbStruct = sizeof(JET_RETINFO);
m_JetErr = JetRetrieveColumn(
GetJetSessionID(),
columns.tableid,
columns.columnidcbMax,
&((m_Columns+index)->cbMaxLength),
sizeof((m_Columns+index)->cbMaxLength),
&cbActual,
0,
&jetRetInfo
);
if(IsSuccess() == FALSE)
continue;
memset(&jetRetInfo, 0, sizeof(JET_RETINFO));
jetRetInfo.cbStruct = sizeof(JET_RETINFO);
m_JetErr = JetRetrieveColumn(
GetJetSessionID(),
columns.tableid,
columns.columnidgrbit,
&((m_Columns+index)->jbGrbit),
sizeof((m_Columns+index)->jbGrbit),
&cbActual,
0,
&jetRetInfo
);
DebugOutput(
_TEXT("Loaded Column name %s, Column Type %d, Column ID %d\n"),
m_Columns[index].pszColumnName,
m_Columns[index].colType,
m_Columns[index].colId
);
if(IsSuccess() == FALSE)
continue;
m_JetErr = JetMove(
GetJetSessionID(),
columns.tableid,
JET_MoveNext,
0
);
}
if(GetLastJetError() == JET_errNoCurrentRecord && index >= columns.cRecord)
{
// otherwise - got to be a JetBlue bug here.
SetLastJetError(JET_errSuccess);
}
//
//
//
cleanup:
FreeJBstr(lpszTableName);
if(IsSuccess() == FALSE && m_Columns)
{
FreeMemory(m_Columns);
m_Columns = NULL;
m_NumColumns = 0;
}
return IsSuccess();
#endif
}
//-------------------------------------------------------------
JET_COLUMNID
JBTable::GetJetColumnID(
LPCTSTR pszColumnName
)
/*
*/
{
int index;
index = GetJetColumnIndex(pszColumnName);
if(index < 0 || index >= m_NumJetColumns)
{
return (DWORD)JET_NIL_COLUMN;
}
return m_JetColumns[index].GetJetColumnID();
}
//-------------------------------------------------------------
int
JBTable::GetJetColumnIndex(
LPCTSTR pszColumnName
)
/*
*/
{
if(m_JetColumns == NULL || m_NumJetColumns == 0)
{
SetLastJetError(JET_errNotInitialized);
return -1;
}
for(int index=0; index < m_NumJetColumns; index++)
{
if(_tcsicmp(m_JetColumns[index].GetJetColumnName(), pszColumnName) == 0)
break;
}
return (index >= m_NumJetColumns) ? -1 : index;
}
//-------------------------------------------------------------
JBColumn*
JBTable::FindColumnByIndex(
const int index
)
/*
*/
{
if(m_JetColumns == NULL || m_NumJetColumns == 0)
{
SetLastJetError(JET_errNotInitialized);
return NULL;
}
if(index < 0 || index >= m_NumJetColumns)
{
SetLastJetError(JET_errInvalidParameter);
return NULL;
}
return m_JetColumns+index;
}
//--------------------------------------------------------------
JBColumn*
JBTable::FindColumnByColumnId(
const JET_COLUMNID JetColId
)
/*
*/
{
if(m_JetColumns == NULL || m_NumJetColumns == 0)
{
SetLastJetError(JET_errNotInitialized);
return NULL;
}
for(int index=0; index < m_NumJetColumns; index++)
{
if(m_JetColumns[index].GetJetColumnID() == JetColId)
break;
}
return FindColumnByIndex( index );
}
//--------------------------------------------------------------
JBColumn*
JBTable::FindColumnByName(
LPCTSTR pszColumnName
)
/*
*/
{
return FindColumnByIndex(GetJetColumnIndex(pszColumnName));
}
//--------------------------------------------------------------
BOOL
JBTable::BeginUpdate(
BOOL bUpdate /* false */
)
/*
*/
{
if(GetTransactionLevel() == 0)
{
SetLastJetError(JET_errNotInTransaction);
JB_ASSERT(FALSE);
return FALSE;
}
SINGLE_JET_CALL;
m_JetErr = JetPrepareUpdate(
GetJetSessionID(),
GetJetTableID(),
(bUpdate) ? JET_prepReplace : JET_prepInsert
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::EndUpdate(
BOOL bDisacrd /* FALSE */
)
/*
*/
{
BYTE pBookmark[JET_cbBookmarkMost+1];
DWORD cbActual = 0;
SINGLE_JET_CALL;
//
// Hack for work item table.
//
m_JetErr = JetUpdate(
GetJetSessionID(),
GetJetTableID(),
pBookmark,
JET_cbBookmarkMost,
&cbActual
);
if(IsSuccess() && m_InsertRepositionBookmark)
{
GotoBookmark(pBookmark, cbActual);
}
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::SetCurrentIndex(
LPCTSTR pszIndexName,
JET_GRBIT grbit /* JET_bitMoveFirst */
)
/*++
--*/
{
if(IsValid() == FALSE || m_InEnumeration == TRUE)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
//
// Can't be in enumeration and and try to set index
//
JB_ASSERT(m_InEnumeration == FALSE);
char* lpszIndexName=NULL;
if(ConvertWstrToJBstr(pszIndexName, &lpszIndexName) == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
{
SINGLE_JET_CALL;
m_JetErr = JetSetCurrentIndex2(
GetJetSessionID(),
GetJetTableID(),
lpszIndexName,
grbit
);
}
if(IsSuccess())
{
m_InEnumeration = TRUE;
}
cleanup:
FreeJBstr(lpszIndexName);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::EnumBegin(
LPCTSTR pszIndexName,
JET_GRBIT grbit /* JET_bitMoveFirst */
)
/*
*/
{
if(m_InEnumeration == TRUE)
{
//
// Force terminate enumeration
//
EnumEnd();
}
return SetCurrentIndex(pszIndexName, grbit);
}
//-------------------------------------------------------------
JBTable::ENUM_RETCODE
JBTable::EnumNext(
JET_GRBIT crow /* JET_MoveNext */,
JET_GRBIT grbit /* 0 */
)
/*
*/
{
if(m_InEnumeration == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
return ENUM_ERROR;
}
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return ENUM_ERROR;
}
ENUM_RETCODE retCode = ENUM_CONTINUE;
while( retCode == ENUM_CONTINUE )
{
MoveToRecord(crow, grbit);
switch(m_JetErr)
{
case JET_errSuccess:
retCode = ENUM_SUCCESS;
break;
case JET_errNoCurrentRecord:
retCode = ENUM_END;
break;
case JET_errRecordDeleted:
retCode = ENUM_CONTINUE;
break;
default:
retCode = ENUM_ERROR;
}
}
return retCode;
}
//-------------------------------------------------------------
BOOL
JBTable::SeekToKey(
JBKeyBase* key,
DWORD dwSeachParam,
JET_GRBIT jetseekgrbit /* =JET_bitSeekGE */
)
/*
*/
{
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
#ifdef DEBUG_SEEK
LPTSTR szKey=key->GetIndexKey();
#endif
EnumBegin(
key->GetIndexName(),
JET_bitMoveFirst
);
if(IsSuccess() == FALSE)
return FALSE;
if(key->IsEmptyValue() == TRUE)
{
return TRUE;
}
PVOID pbData;
unsigned long cbData;
JET_GRBIT key_grbit=JET_bitNewKey;
SetLastJetError(JET_errSuccess);
for(DWORD dwComponent=0;
dwComponent < key->GetNumKeyComponents();
dwComponent++)
{
if(key->GetSearchKey(dwComponent, &pbData, &cbData, &key_grbit, dwSeachParam) == FALSE)
break;
if(MakeKey(pbData, cbData, key_grbit) == FALSE)
break;
}
#ifdef DEBUG_SEEK
PVOID pb=NULL;
DWORD cb=0;
unsigned long actual;
SINGLE_JET_CALL;
m_JetErr = JetRetrieveKey(
GetJetSessionID(),
GetJetTableID(),
pb,
cb,
&actual,
0
);
pb = (PVOID)AllocateMemory(actual);
cb = actual;
m_JetErr = JetRetrieveKey(
GetJetSessionID(),
GetJetTableID(),
pb,
cb,
&actual,
0
);
FreeMemory(pb);
#endif
return IsSuccess() ? SeekValue(jetseekgrbit) : FALSE;
}
//-------------------------------------------------------------
BOOL
JBTable::EnumBegin(
JBKeyBase* key,
DWORD dwSearchParam
)
/*
*/
{
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
return FALSE;
}
if(m_InEnumeration == TRUE)
{
// what do we do???
}
return SeekToKey(key, dwSearchParam);
}
//-------------------------------------------------------------
BOOL
JBTable::GetCurrentIndex(
LPTSTR pszIndexName,
unsigned long* bufferSize
)
/*
*/
{
char lpszIndexName[MAX_JETBLUE_NAME_LENGTH+1];
int NumChars=0;
SINGLE_JET_CALL;
m_JetErr = JetGetCurrentIndex(
GetJetSessionID(),
GetJetTableID(),
lpszIndexName,
sizeof(lpszIndexName)
);
if(IsSuccess() == FALSE)
goto cleanup;
NumChars = MultiByteToWideChar(
GetACP(),
MB_PRECOMPOSED,
lpszIndexName,
-1,
pszIndexName,
*bufferSize
);
if(NumChars == 0)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
*bufferSize = NumChars;
cleanup:
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::GetBookmark(
PVOID pbBuffer,
PDWORD pcbBufSize
)
/*++
--*/
{
DWORD cbBufferSize = *pcbBufSize;
SINGLE_JET_CALL;
m_JetErr = JetGetBookmark(
GetJetSessionID(),
GetJetTableID(),
pbBuffer,
cbBufferSize,
pcbBufSize
);
if(m_JetErr == JET_errBufferTooSmall)
{
SetLastJetError(m_JetErr);
SetLastError(ERROR_INSUFFICIENT_BUFFER);
}
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::GotoBookmark(
PVOID pbBuffer,
DWORD cbBuffer
)
/*++
--*/
{
SINGLE_JET_CALL;
m_JetErr = JetGotoBookmark(
GetJetSessionID(),
GetJetTableID(),
pbBuffer,
cbBuffer
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::ReadLock()
{
SINGLE_JET_CALL;
m_JetErr = JetGetLock(
GetJetSessionID(),
GetJetTableID(),
JET_bitReadLock
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::WriteLock()
{
SINGLE_JET_CALL;
m_JetErr = JetGetLock(
GetJetSessionID(),
GetJetTableID(),
JET_bitWriteLock
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::RetrieveKey(
PVOID pbData,
unsigned long cbData,
unsigned long* pcbActual,
JET_GRBIT grbit
)
/*
*/
{
unsigned long cbActual;
SINGLE_JET_CALL;
m_JetErr = JetRetrieveKey(
GetJetSessionID(),
GetJetTableID(),
pbData,
cbData,
(pcbActual) ? pcbActual : &cbActual,
grbit // user2.doc - unuse.
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::MoveToRecord(
long crow,
JET_GRBIT grbit
)
/*
*/
{
SINGLE_JET_CALL;
m_JetErr = JetMove(
GetJetSessionID(),
GetJetTableID(),
crow,
grbit
);
return IsSuccess();
}
//-------------------------------------------------------------
unsigned long
JBTable::GetIndexRecordCount(
unsigned long max
)
/*
*/
{
unsigned long count;
SINGLE_JET_CALL;
m_JetErr = JetIndexRecordCount(
GetJetSessionID(),
GetJetTableID(),
&count,
max
);
return IsSuccess() ? count : 0;
}
//-------------------------------------------------------------
BOOL
JBTable::MakeKey(
PVOID pbData,
unsigned long cbData,
JET_GRBIT grbit
)
/*
*/
{
SINGLE_JET_CALL;
m_JetErr = JetMakeKey(
GetJetSessionID(),
GetJetTableID(),
pbData,
cbData,
grbit
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::SeekValue(
JET_GRBIT grbit
)
/*
*/
{
SINGLE_JET_CALL;
m_JetErr = JetSeek(
GetJetSessionID(),
GetJetTableID(),
grbit
);
return IsSuccess();
}
//-------------------------------------------------------------
BOOL
JBTable::DeleteRecord()
/*
*/
{
SINGLE_JET_CALL;
// must have current record set
m_JetErr = JetDelete(
GetJetSessionID(),
GetJetTableID()
);
return IsSuccess();
}
//
//////////////////////////////////////////////////////////////
//
CLASS_PRIVATE void
JBColumn::Cleanup()
/*
*/
{
memset(m_szColumnName, 0, sizeof(m_szColumnName));
}
//-----------------------------------------------------------
JBColumn::JBColumn(JBTable* pJetTable) :
m_pJetTable(pJetTable),
m_JetColId(0),
m_JetColType(JET_coltypNil),
m_JetMaxColLength(0),
m_JetGrbit(0),
m_JetColCodePage(TLS_JETBLUE_COLUMN_CODE_PAGE),
m_JetColCountryCode(TLS_JETBLUE_COLUMN_COUNTRY_CODE),
m_JetColLangId(TLS_JETBLUE_COLUMN_LANGID),
m_cbActual(0),
m_pbDefValue(NULL),
m_cbDefValue(0),
m_JetNullColumn(FALSE)
/*
*/
{
Cleanup();
}
//-----------------------------------------------------------
CLASS_PRIVATE JET_ERR
JBColumn::RetrieveColumnValue(
IN JET_SESID sesid,
IN JET_TABLEID tableid,
IN JET_COLUMNID columnid,
IN OUT PVOID pbBuffer,
IN unsigned long cbBuffer,
IN unsigned long offset
)
/*
*/
{
m_JetRetInfo.cbStruct = sizeof(m_JetRetInfo);
m_JetRetInfo.ibLongValue = offset;
m_JetNullColumn = FALSE;
m_cbActual = 0;
SINGLE_JET_CALL;
//
// JETBLUE bug??? passing zeror buffer size returns Column NULL
//
m_JetErr = JetRetrieveColumn(
sesid,
tableid,
columnid,
pbBuffer,
cbBuffer,
&m_cbActual,
0,
NULL // &m_JetRetInfo
);
if(m_JetErr == JET_wrnColumnNull)
m_JetNullColumn = TRUE;
return IsSuccess();
}
//-----------------------------------------------------------
CLASS_PRIVATE BOOL
JBColumn::LoadJetColumnInfoFromJet(
const JET_COLUMNLIST* pColumnList
)
/*
*/
{
char lpszColumnName[MAX_JETBLUE_NAME_LENGTH+1];
int NumChars;
//
// retrieve column name
//
RetrieveColumnValue(
GetJetSessionID(),
pColumnList->tableid,
pColumnList->columnidcolumnname,
lpszColumnName,
sizeof(lpszColumnName)
);
if(IsSuccess() == FALSE)
goto cleanup;
NumChars = MultiByteToWideChar(
GetACP(),
MB_PRECOMPOSED,
lpszColumnName,
m_cbActual,
m_szColumnName,
sizeof(m_szColumnName)/sizeof(m_szColumnName[0])
);
if(NumChars == 0)
{
SetLastJetError(JET_errInvalidParameter);
goto cleanup;
}
//DebugOutput(
// _TEXT("Load column %s"),
// m_szColumnName
// );
//
// retrieve column ID
//
RetrieveColumnValue(
GetJetSessionID(),
pColumnList->tableid,
pColumnList->columnidcolumnid,
&m_JetColId,
sizeof(m_JetColId)
);
if(IsSuccess() == FALSE)
goto cleanup;
//DebugOutput(
// _TEXT("\tColId - %d"),
// m_JetColId
// );
//
// Retrieve Column Type
//
RetrieveColumnValue(
GetJetSessionID(),
pColumnList->tableid,
pColumnList->columnidcoltyp,
&m_JetColType,
sizeof(m_JetColType)
);
if(IsSuccess() == FALSE)
goto cleanup;
//DebugOutput(
// _TEXT("\tCol Type %d"),
// m_JetColType
// );
//
// Retrieve Max. length for LongText and Long Binary
//
RetrieveColumnValue(
GetJetSessionID(),
pColumnList->tableid,
pColumnList->columnidcbMax,
&m_JetMaxColLength,
sizeof(m_JetMaxColLength)
);
if(IsSuccess() == FALSE)
goto cleanup;
//DebugOutput(
// _TEXT("\tMax Col Length %d"),
// m_JetMaxColLength
// );
//
// Retrieve Column Grbit
//
RetrieveColumnValue(
GetJetSessionID(),
pColumnList->tableid,
pColumnList->columnidgrbit,
&m_JetGrbit,
sizeof(m_JetGrbit)
);
if(IsSuccess() == FALSE)
goto cleanup;
//DebugOutput(
// _TEXT("\tCol grbit %d"),
// m_JetGrbit
// );
cleanup:
//DebugOutput(
// _TEXT("\n")
// );
return IsSuccess();
}
//-----------------------------------------------------------
BOOL
JBColumn::IsValid() const
/*
*/
{
return m_pJetTable != NULL && m_pJetTable->IsValid();
}
//-----------------------------------------------------------
BOOL
JBColumn::InsertColumn(
PVOID pbData,
unsigned long cbData,
unsigned long offset
)
/*
*/
{
//JET_SETINFO setinfo;
if(IsValid() == FALSE)
{
SetLastJetError(JET_errInvalidParameter);
return IsSuccess();
}
SINGLE_JET_CALL;
// if(GetJetColumnType() == JET_coltypLongText || GetJetColumnType() == JET_coltypLongBinary)
if(pbData == NULL || cbData == 0)
{
m_JetErr = JetSetColumn(
GetJetSessionID(),
GetJetTableID(),
GetJetColumnID(),
0,
0,
JET_bitSetZeroLength,
NULL
);
if(IsSuccess() == FALSE)
return FALSE;
m_JetErr = JetSetColumn(
GetJetSessionID(),
GetJetTableID(),
GetJetColumnID(),
0,
0,
0,
NULL
);
if(IsSuccess() == FALSE)
return FALSE;
}
m_JetErr = JetSetColumn(
GetJetSessionID(),
GetJetTableID(),
GetJetColumnID(),
pbData,
cbData,
0,
NULL
);
return IsSuccess();
}
//-----------------------------------------------------------
BOOL
JBColumn::FetchColumn(
PVOID pbData,
unsigned long cbData,
unsigned long starting_offset
)
/*
pass NULL and 0 to determine buffer size needed.
*/
{
if(IsValid() == FALSE)
{
SetLastJetError(JET_errNotInitialized);
}
else
{
RetrieveColumnValue(
GetJetSessionID(),
GetJetTableID(),
GetJetColumnID(),
pbData,
cbData,
starting_offset
);
}
return IsSuccess();
}
Reference in a new issue Copy permalink