You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
538 lines
16 KiB
538 lines
16 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
//============================================================================= |
|
|
|
|
|
#include "stdafx.h" |
|
|
|
//#include "sqlaccess.h" |
|
|
|
// memdbgon must be the last include file in a .cpp file!!! |
|
#include "tier0/memdbgon.h" |
|
|
|
namespace GCSDK |
|
{ |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Constructor |
|
//----------------------------------------------------------------------------- |
|
CSQLRecord::CSQLRecord( uint32 unRow, IGCSQLResultSet *pResultSet ) |
|
{ |
|
Init( unRow, pResultSet ); |
|
} |
|
CSQLRecord::CSQLRecord() |
|
: m_pResultSet( NULL ), m_unRow( 0 ) |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Destructor |
|
//----------------------------------------------------------------------------- |
|
CSQLRecord::~CSQLRecord() |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Initializes a blank record |
|
// Input: iTable - table that this record will belong to |
|
//----------------------------------------------------------------------------- |
|
void CSQLRecord::Init( uint32 unRow, IGCSQLResultSet *pResultSet ) |
|
{ |
|
if( unRow >= pResultSet->GetRowCount() ) |
|
{ |
|
m_pResultSet = NULL; |
|
m_unRow = 0; |
|
} |
|
else |
|
{ |
|
m_pResultSet = pResultSet; |
|
m_unRow = unRow; |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets data for a field in this record |
|
// Input: unColumn - field to get |
|
// pubField - pointer to get filled in with pointer to data |
|
// cubField - pointer to get filled in with size of data |
|
// Output: true if successful, false if data not present |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetColumnData( uint32 unColumn, uint8 **ppubField, int *pcubField ) |
|
{ |
|
size_t sz; |
|
bool bRet = BGetColumnData( unColumn, ppubField, &sz ); |
|
*pcubField = static_cast< int >( sz ); |
|
return bRet; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets data for a field in this record |
|
// Input: unColumn - field to get |
|
// pubField - pointer to get filled in with pointer to data |
|
// cubField - pointer to get filled in with size of data |
|
// Output: true if successful, false if data not present |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetColumnData( uint32 unColumn, uint8 **ppubField, size_t *pcubField ) |
|
{ |
|
Assert( ppubField ); |
|
Assert( pcubField ); |
|
*ppubField = NULL; |
|
*pcubField = 0; |
|
|
|
Assert( m_pResultSet ); |
|
|
|
if ( !BValidateColumnIndex( unColumn ) ) |
|
return false; |
|
|
|
*pcubField = 0; |
|
return m_pResultSet->GetData( m_unRow, unColumn, ppubField, (uint32*)pcubField ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets string data for a field in this record |
|
// Input: unColumn - field to get |
|
// ppchVal - pointer to pointer to fill in to string data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetStringValue( uint32 unColumn, const char **ppchVal ) |
|
{ |
|
Assert( ppchVal ); |
|
*ppchVal = NULL; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
Assert( k_EGCSQLType_String == m_pResultSet->GetColumnType( unColumn ) ); |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
*ppchVal = (const char *) pubData; |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets string data for a field in this record |
|
// Input: unColumn - field to get |
|
// ppchVal - pointer to pointer to fill in to string data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetStringValue( uint32 unColumn, CFmtStr1024 *psVal ) |
|
{ |
|
Assert( psVal ); |
|
*psVal = ""; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
Assert( k_EGCSQLType_String == m_pResultSet->GetColumnType( unColumn ) ); |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
*psVal = (const char *) pubData; |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets int data for a field in this record |
|
// Input: unColumn - field to get |
|
// pnVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetIntValue( uint32 unColumn, int *pnVal ) |
|
{ |
|
Assert( pnVal ); |
|
*pnVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
switch( m_pResultSet->GetColumnType( unColumn ) ) |
|
{ |
|
case k_EGCSQLType_int64: |
|
{ |
|
int64 ul = *((int64 *)pubData); |
|
if ( ul >= LONG_MIN && ul <= LONG_MAX ) |
|
{ |
|
*pnVal = (int)ul; |
|
return true; |
|
} |
|
else |
|
{ |
|
AssertMsg1(false, "GetIntValue tried to catch %lld in an int, which is too small", ul ); |
|
return false; |
|
} |
|
} |
|
break; |
|
|
|
case k_EGCSQLType_int32: |
|
*pnVal = *((int32 *)pubData); |
|
return true; |
|
|
|
case k_EGCSQLType_int16: |
|
*pnVal = *((int16 *)pubData); |
|
return true; |
|
|
|
case k_EGCSQLType_int8: |
|
*pnVal = *((int8 *)pubData); |
|
return true; |
|
|
|
default: |
|
AssertMsg1(false, "GetIntValue tried to catch a %s, which is the wrong type", PchNameFromEGCSQLType( m_pResultSet->GetColumnType( unColumn ) ) ); |
|
return false; |
|
} |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets float data for a field in this record |
|
// Input: unColumn - field to get |
|
// pnVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetFloatValue( uint32 unColumn, float *pfVal ) |
|
{ |
|
Assert( pfVal ); |
|
*pfVal = 0.0f; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_float == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg2( sizeof( float ) == cubData, "GetValue expected %llu bytes, found %d", (uint64)sizeof( float ), cubData ); |
|
if ( sizeof( float ) != cubData ) |
|
return false; |
|
*pfVal = *( (float *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets double data for a field in this record |
|
// Input: unColumn - field to get |
|
// pnVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetDoubleValue( uint32 unColumn, double *pdVal ) |
|
{ |
|
Assert( pdVal ); |
|
*pdVal = 0.0f; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_double == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg2( sizeof( double ) == cubData, "GetValue expected %llu bytes, found %d", (uint64)sizeof( double ), cubData ); |
|
if ( sizeof( double ) != cubData ) |
|
return false; |
|
*pdVal = *( (double *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets int data for a field in this record |
|
// Input: unColumn - field to get |
|
// pVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetByteValue( uint32 unColumn, byte *pVal ) |
|
{ |
|
Assert( pVal ); |
|
*pVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int8 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 1 == cubData, "GetValue expected 1 bytes, found %d", cubData ); |
|
if ( 1 != cubData ) |
|
return false; |
|
*pVal = *( (byte *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets int data for a field in this record |
|
// Input: unColumn - field to get |
|
// pVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetBoolValue( uint32 unColumn, bool *pVal ) |
|
{ |
|
int32 b; |
|
if ( !BGetIntValue( unColumn, &b ) ) |
|
return false; |
|
|
|
// convert to boolean |
|
*pVal = ( b != 0 ); |
|
|
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets int16 data for a field in this record |
|
// Input: unColumn - field to get |
|
// pnVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetInt16Value( uint32 unColumn, int16 *pnVal ) |
|
{ |
|
Assert( pnVal ); |
|
*pnVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int16 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 2 == cubData, "GetValue expected 2 bytes, found %d", cubData ); |
|
if ( 2 != cubData ) |
|
return false; |
|
*pnVal = *( (int16 *) pubData ); |
|
} |
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets int64 data for a field in this record |
|
// Input: unColumn - field to get |
|
// puVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetInt64Value( uint32 unColumn, int64 *puVal ) |
|
{ |
|
Assert( puVal ); |
|
*puVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int64 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 8 == cubData, "GetValue expected 8 bytes, found %d", cubData ); |
|
if ( 8 != cubData ) |
|
return false; |
|
*puVal = *( (int64 *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets uint64 data for a field in this record |
|
// Input: unColumn - field to get |
|
// puVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetUint64Value( uint32 unColumn, uint64 *puVal ) |
|
{ |
|
Assert( puVal ); |
|
*puVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int64 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 8 == cubData, "GetValue expected 8 bytes, found %d", cubData ); |
|
if ( 8 != cubData ) |
|
return false; |
|
*puVal = *( (uint64 *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets uint32 data for a field in this record |
|
// Input: unColumn - field to get |
|
// puVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetUint32Value( uint32 unColumn, uint32 *puVal ) |
|
{ |
|
Assert( puVal ); |
|
*puVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int32 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 4 == cubData, "GetValue expected 4 bytes, found %d", cubData ); |
|
if ( 4 != cubData ) |
|
return false; |
|
*puVal = *( (uint32 *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets uint16 data for a field in this record |
|
// Input: unColumn - field to get |
|
// puVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetUint16Value( uint32 unColumn, uint16 *puVal ) |
|
{ |
|
Assert( puVal ); |
|
*puVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int16 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 2 == cubData, "GetValue expected 2 bytes, found %d", cubData ); |
|
if ( 2 != cubData ) |
|
return false; |
|
*puVal = *( (uint16 *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Gets uint8 data for a field in this record |
|
// Input: unColumn - field to get |
|
// puVal - pointer to fill in with data |
|
// Output: true if successful, false if data not present or not of correct type |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BGetUint8Value( uint32 unColumn, uint8 *puVal ) |
|
{ |
|
Assert( puVal ); |
|
*puVal = 0; |
|
|
|
uint8 *pubData = NULL; |
|
int cubData = 0; |
|
bool bRet = BGetColumnData( unColumn, &pubData, &cubData ); |
|
if ( bRet ) |
|
{ |
|
Assert( k_EGCSQLType_int8 == m_pResultSet->GetColumnType( unColumn ) ); |
|
AssertMsg1( 1 == cubData, "GetValue expected 1 byte, found %d", cubData ); |
|
if ( 1 != cubData ) |
|
return false; |
|
*puVal = *( (uint8 *) pubData ); |
|
} |
|
|
|
return bRet; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Validates column index |
|
// Input: unColumn - field to validate |
|
// Output: true if valid, false otherwise |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BValidateColumnIndex( uint32 unColumn ) |
|
{ |
|
if ( unColumn >= m_pResultSet->GetColumnCount() ) |
|
{ |
|
AssertMsg2( false, "CSQLRecord::BValidateColumnIndex: invalid column index %d. # columns: %d", unColumn, |
|
m_pResultSet->GetColumnCount() ); |
|
return false; |
|
} |
|
return true; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Advances the CSQLRecord to the next row |
|
// Output: returns false if this call would advance the record past the last row. |
|
// And makes the record invalid. |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::NextRow() |
|
{ |
|
Assert( m_pResultSet ); |
|
m_unRow++; |
|
|
|
if( m_unRow >= m_pResultSet->GetRowCount() ) |
|
m_pResultSet = NULL; |
|
return IsValid(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Render a field to a buffer |
|
// Input: unColumn - field to render |
|
// cchBuffer - size of render buffer |
|
// pchBuffer - buffer to render into |
|
//----------------------------------------------------------------------------- |
|
void CSQLRecord::RenderField( uint32 unColumn, int cchBuffer, char *pchBuffer ) |
|
{ |
|
Q_strncpy( pchBuffer, "", cchBuffer ); |
|
|
|
uint8 *pubData; |
|
int cubData; |
|
if ( !BGetColumnData( unColumn, &pubData, &cubData ) ) |
|
return; |
|
|
|
// Get the column info and figure out how to interpret the data |
|
ConvertFieldToText( m_pResultSet->GetColumnType( unColumn ), pubData, cubData, pchBuffer, cchBuffer, false ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: Copies a CSQLRecord to CRecordBase |
|
//----------------------------------------------------------------------------- |
|
bool CSQLRecord::BWriteToRecord( CRecordBase *pRecord, const CColumnSet & csWriteFields ) |
|
{ |
|
bool bSuccess = true; |
|
FOR_EACH_COLUMN_IN_SET( csWriteFields, unSQLColumn ) |
|
{ |
|
uint32 unRecordColumn = csWriteFields.GetColumn( unSQLColumn ); |
|
|
|
uint8 *pubData; |
|
size_t cubData; |
|
if( !BGetColumnData( unSQLColumn, &pubData, &cubData ) ) |
|
{ |
|
bSuccess = false; |
|
} |
|
else |
|
{ |
|
bSuccess = pRecord->BSetField( unRecordColumn, pubData, cubData ) && bSuccess; |
|
} |
|
|
|
} |
|
return bSuccess; |
|
} |
|
|
|
|
|
|
|
} // namespace GCSDK
|
|
|