1506 lines
49 KiB
C++
1506 lines
49 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
|
|
|
|
#include "stdafx.h"
|
|
//#include "sqlaccess/sqlaccess.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
namespace GCSDK
|
|
{
|
|
#ifndef STEAM
|
|
bool isspace( char ch )
|
|
{
|
|
return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
|
|
}
|
|
|
|
int Q_strnlen( const char *str, int count )
|
|
{
|
|
// can't make more meaningful checks, because this routine is used itself
|
|
// to check the NUL-terminatedness of strings
|
|
if ( !str || count < 0 )
|
|
return -1;
|
|
|
|
for ( const char *pch = str; pch < str + count; pch++ )
|
|
{
|
|
if ( *pch == '\0' )
|
|
return pch - str;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: convert an ESchemaCatalog into a string for diagnostics and logging.
|
|
// this can't be in enum_names because of data type dependencies.
|
|
//-----------------------------------------------------------------------------
|
|
const char* PchNameFromESchemaCatalog( ESchemaCatalog e )
|
|
{
|
|
switch (e)
|
|
{
|
|
case k_ESchemaCatalogInvalid:
|
|
return "k_ESchemaCatalogInvalid";
|
|
break;
|
|
|
|
case k_ESchemaCatalogMain:
|
|
return "k_ESchemaCatalogMain";
|
|
break;
|
|
}
|
|
|
|
AssertMsg1( false, "unknown ESchemaCatalog (%d)", e );
|
|
return "Unknown";
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CSchema::CSchema()
|
|
{
|
|
m_iTable = -1;
|
|
m_rgchName[0] = 0;
|
|
m_cubRecord = 0;
|
|
m_bTestTable = false;
|
|
m_cRecordMax = 0;
|
|
m_bHasVarFields = false;
|
|
m_nHasPrimaryKey = k_EPrimaryKeyTypeNone;
|
|
m_iPKIndex = -1;
|
|
m_pRecordInfo = NULL;
|
|
m_wipePolicy = k_EWipePolicyPreserveAlways;
|
|
m_bAllowWipeInProd = false;
|
|
m_bPrepopulatedTable = false;
|
|
m_nFullTextIndexCatalog = -1;
|
|
m_eSchemaCatalog = k_ESchemaCatalogInvalid;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CSchema::~CSchema()
|
|
{
|
|
SAFE_RELEASE( m_pRecordInfo );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Calculates offset of each field within a record structure, and the
|
|
// maximum length of a record structure.
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::CalcOffsets()
|
|
{
|
|
int dubOffsetCur = 0;
|
|
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
m_VecField[iField].m_dubOffset = dubOffsetCur;
|
|
dubOffsetCur += m_VecField[iField].m_cubLength;
|
|
|
|
if ( m_VecField[iField].BIsVariableLength() )
|
|
m_bHasVarFields = true;
|
|
}
|
|
|
|
m_cubRecord = dubOffsetCur;
|
|
|
|
if ( m_bHasVarFields )
|
|
m_cubRecord += sizeof( VarFieldBlockInfo_t );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: called to make final calculations when all fields/indexes/etc have
|
|
// been added and the schema is ready to be used
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::PrepareForUse()
|
|
{
|
|
// Create a record description (new form of schema information, for SQL) that corresponds to this schema object.
|
|
// This contains essentially the information as the CSchema object, we keep both for the moment to bridge the DS and SQL worlds.
|
|
Assert( !m_pRecordInfo );
|
|
SAFE_RELEASE( m_pRecordInfo );
|
|
m_pRecordInfo = CRecordInfo::Alloc();
|
|
m_pRecordInfo->InitFromDSSchema( this );
|
|
}
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: For a record that has variable-length fields, gets the info block from
|
|
// the tail end
|
|
// Input : pvRecord - Record data
|
|
//-----------------------------------------------------------------------------
|
|
VarFieldBlockInfo_t* CSchema::PVarFieldBlockInfoFromRecord( const void *pvRecord ) const
|
|
{
|
|
if ( !m_bHasVarFields )
|
|
return NULL;
|
|
|
|
uint8 *pubRecord = ( uint8* )pvRecord;
|
|
return ( VarFieldBlockInfo_t * )( pubRecord + m_cubRecord ) - 1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the total size of the variable-length block for this record
|
|
// For records that have no variable-length fields, it will return zero
|
|
// Input : pvRecord - Record data
|
|
//-----------------------------------------------------------------------------
|
|
uint32 CSchema::CubRecordVariable( const void *pvRecord ) const
|
|
{
|
|
VarFieldBlockInfo_t *pVarFieldsBlockInfo = PVarFieldBlockInfoFromRecord( pvRecord );
|
|
if ( pVarFieldsBlockInfo )
|
|
return pVarFieldsBlockInfo->m_cubBlock;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void CSchema::RenderField( uint8 *pubRecord, int iField, int cchBuffer, char *pchBuffer )
|
|
{
|
|
Field_t *pField = &m_VecField[iField];
|
|
|
|
uint8 *pubData;
|
|
uint32 cubData;
|
|
char chEmpty = 0;
|
|
|
|
if ( pField->BIsVariableLength() )
|
|
{
|
|
if ( !BGetVarField( pubRecord, ( VarField_t * )( pubRecord + pField->m_dubOffset ), &pubData, &cubData ) )
|
|
{
|
|
// just render a single byte
|
|
pubData = ( uint8* )&chEmpty;
|
|
cubData = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pubData = pubRecord + pField->m_dubOffset;
|
|
cubData = m_VecField[iField].m_cubLength;
|
|
}
|
|
|
|
ConvertFieldToText( pField->m_EType, pubData, cubData, pchBuffer, cchBuffer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Renders a text version of a record to the console.
|
|
// Input : pubRecord - Location of the record data
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::RenderRecord( uint8 *pubRecord )
|
|
{
|
|
char rgchT[k_cMedBuff];
|
|
|
|
// First the header
|
|
EmitInfo( SPEW_CONSOLE, 2, 2, "%d\t*** Record header: # of lines ***\n", 1 + m_VecField.Count() );
|
|
|
|
// Render each field in turn
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
Field_t *pField = &m_VecField[iField];
|
|
|
|
RenderField( pubRecord, iField, Q_ARRAYSIZE(rgchT), rgchT );
|
|
|
|
EmitInfo( SPEW_CONSOLE, 2, 2, "\t%s\t\t// Field %d (%s)\n", rgchT, iField, pField->m_rgchName );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get data and size of a field, whether fixed or variable length
|
|
// Input: pvRecord - Fixed-length part of record
|
|
// iField - index of field to get
|
|
// ppubField - receives pointer to field data
|
|
// pcubField - receives size in bytes of that data
|
|
// Output: true if successful
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchema::BGetFieldData( const void *pvRecord, int iField, uint8 **ppubField, uint32 *pcubField ) const
|
|
{
|
|
*ppubField = NULL;
|
|
*pcubField = 0;
|
|
const Field_t &field = m_VecField[iField];
|
|
if ( field.BIsVariableLength() )
|
|
{
|
|
return BGetVarField( pvRecord, ( VarField_t * )( ( uint8 * ) pvRecord + field.m_dubOffset ), ppubField, pcubField );
|
|
}
|
|
else
|
|
{
|
|
*ppubField = ( ( uint8 * ) pvRecord + field.m_dubOffset );
|
|
*pcubField = field.CubFieldUpdateSize();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set data and size of a field, whether fixed or variable length
|
|
// Input: pvRecord - Fixed-length part of record
|
|
// iField - index of field to set
|
|
// pubField - pointer to field data to copy from
|
|
// cubField - size in bytes of that data
|
|
// Output: true if successful
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchema::BSetFieldData( void *pvRecord, int iField, uint8 *pubField, uint32 cubField, bool *pbVarBlockRealloced )
|
|
{
|
|
*pbVarBlockRealloced = false;
|
|
|
|
Field_t &field = m_VecField[iField];
|
|
|
|
if ( field.BIsVariableLength() )
|
|
{
|
|
return BSetVarField( pvRecord, ( VarField_t * )( ( uint8 * ) pvRecord + field.m_dubOffset ), pubField, cubField, pbVarBlockRealloced, /*bFreeOnRealloc*/ true );
|
|
}
|
|
else // fixed length
|
|
{
|
|
uint8 *pubFieldWrite = ( ( uint8 * ) pvRecord + field.m_dubOffset );
|
|
|
|
// Must fit in field and last byte for strings MUST be NULL
|
|
if ( cubField > field.m_cubLength ||
|
|
( k_EGCSQLType_String == field.m_EType && Q_strnlen( reinterpret_cast< char* >( pubField ), cubField ) == -1 ) )
|
|
{
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
|
|
if ( k_EGCSQLType_Blob != field.m_EType && k_EGCSQLType_Image != field.m_EType )
|
|
{
|
|
// Copy the data (string or binary, doesn't matter)
|
|
if ( cubField > 0 )
|
|
Q_memcpy( pubFieldWrite, pubField, cubField );
|
|
|
|
// Null termination and overwrite any old data
|
|
if ( cubField < field.m_cubLength )
|
|
Q_memset( pubFieldWrite + cubField, 0, field.m_cubLength - cubField );
|
|
}
|
|
else
|
|
{
|
|
// Only support fixed char or binary
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get data from a variable-length field
|
|
// Input: pvRecord - Fixed-length part of record
|
|
// pVarField - fixed part of field in that record
|
|
// ppubField - receives pointer to field data
|
|
// pcubField - receives size in bytes of that data
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchema::BGetVarField( const void *pvRecord, const VarField_t *pVarField, uint8 **ppubField, uint32 *pcubField ) const
|
|
{
|
|
Assert( m_bHasVarFields );
|
|
|
|
*ppubField = 0;
|
|
*pcubField = 0;
|
|
|
|
VarFieldBlockInfo_t *pVarFieldBlockInfo = PVarFieldBlockInfoFromRecord( pvRecord );
|
|
|
|
if ( !pVarField->m_cubField )
|
|
{
|
|
*pcubField = 0;
|
|
*ppubField = NULL;
|
|
return true;
|
|
}
|
|
|
|
if ( pVarFieldBlockInfo->m_cubBlock )
|
|
{
|
|
uint8 *pubVarBlock = pVarFieldBlockInfo->m_pubBlock;
|
|
|
|
*ppubField = pubVarBlock + pVarField->m_dubOffset;
|
|
*pcubField = pVarField->m_cubField;
|
|
|
|
// Sanity check
|
|
Assert( *pcubField <= k_cubVarFieldMax );
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// Should never happen
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update a variable-length field in a record (may realloc the var block)
|
|
// Input: pvRecord - Fixed-length part of record
|
|
// pVarField - fixed part of field in that record
|
|
// pvData - data to place in the field
|
|
// cubData - size of that data
|
|
// pbRealloced - set to indicate if the var block was realloced
|
|
// bFreeOnRealloc - If we have to grow or shrink the var block, should we free the old memory?
|
|
// Usually true, unless it lives in a NetPacket or something like that
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchema::BSetVarField( void *pvRecord, VarField_t *pVarField, const void *pvData, uint32 cubData, bool *pbRealloced, bool bFreeOnRealloc )
|
|
{
|
|
VarFieldBlockInfo_t *pVarFieldBlockInfo = PVarFieldBlockInfoFromRecord( pvRecord );
|
|
*pbRealloced = false;
|
|
|
|
|
|
if ( cubData > k_cubVarFieldMax )
|
|
{
|
|
// field size is too big
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
|
|
// if no block exists, allocate and copy into it
|
|
if ( pVarFieldBlockInfo->m_cubBlock == 0 )
|
|
{
|
|
// Nothing to do?
|
|
if ( !cubData )
|
|
return true;
|
|
|
|
// create it
|
|
void *pvBlock = PvAlloc( cubData );
|
|
*pbRealloced = true;
|
|
|
|
// copy the data
|
|
Q_memcpy( pvBlock, pvData, cubData );
|
|
|
|
// set the record's structure to point at our new data
|
|
pVarFieldBlockInfo->m_cubBlock = cubData;
|
|
pVarFieldBlockInfo->m_pubBlock = ( uint8 * )pvBlock;
|
|
|
|
// set the field to point at its landing place
|
|
pVarField->m_cubField = cubData;
|
|
pVarField->m_dubOffset = 0;
|
|
}
|
|
else
|
|
{
|
|
// there is some block available.
|
|
|
|
// is this field changing size?
|
|
if ( cubData != 0 && ( cubData == pVarField->m_cubField ) )
|
|
{
|
|
// no size change - no need to reallocate anything
|
|
Q_memcpy( pVarFieldBlockInfo->m_pubBlock + pVarField->m_dubOffset, pvData, cubData );
|
|
}
|
|
else
|
|
{
|
|
// size change - realloc
|
|
*pbRealloced = true;
|
|
uint32 cubFieldOld = pVarField->m_cubField;
|
|
uint32 dubOffsetOld = pVarField->m_dubOffset;
|
|
uint32 cubBlockNew = pVarFieldBlockInfo->m_cubBlock - pVarField->m_cubField + cubData;
|
|
|
|
if ( ( cubBlockNew + m_cubRecord ) > k_cubRecordMax )
|
|
{
|
|
// total record size is too big
|
|
Assert( false );
|
|
return false;
|
|
}
|
|
|
|
void *pvBlockNew = NULL;
|
|
|
|
if ( cubBlockNew )
|
|
{
|
|
// if this field has never been placed in the block (that is, it's not changing an old value)
|
|
// and we have enough space, fastest to put it at the end in the free space.
|
|
if ( pVarField->m_cubField == 0 && pVarField->m_dubOffset == 0 && cubData <= pVarFieldBlockInfo->m_cubBlockFree )
|
|
{
|
|
uint8 *pubLastUsed = pVarFieldBlockInfo->m_pubBlock;
|
|
for ( int iField = 0; iField < m_VecField.Count(); ++iField )
|
|
{
|
|
Field_t &field = m_VecField[iField];
|
|
if ( field.BIsVariableLength() )
|
|
{
|
|
// Needs updating
|
|
VarField_t *pVarFieldCur = ( VarField_t * )( ( uint8 * )pvRecord + field.m_dubOffset );
|
|
pubLastUsed += pVarFieldCur->m_cubField;
|
|
}
|
|
}
|
|
|
|
// copy it there
|
|
Q_memcpy( pubLastUsed, pvData, cubData );
|
|
|
|
// set up the field
|
|
pVarField->m_cubField = cubData;
|
|
pVarField->m_dubOffset = static_cast<int>( (pubLastUsed - pVarFieldBlockInfo->m_pubBlock) );
|
|
|
|
// note that we used some up
|
|
pVarFieldBlockInfo->m_cubBlockFree -= cubData;
|
|
}
|
|
else
|
|
{
|
|
// yes ... rellocate
|
|
pvBlockNew = PvAlloc( cubBlockNew );
|
|
|
|
uint8 *pubBlockOldCursor = pVarFieldBlockInfo->m_pubBlock;
|
|
uint8 *pubBlockNewCursor = ( uint8* )pvBlockNew;
|
|
|
|
// copy data, skipping over this field (will put at end)
|
|
while ( pubBlockOldCursor < ( pVarFieldBlockInfo->m_pubBlock + pVarFieldBlockInfo->m_cubBlock ) )
|
|
{
|
|
if ( pVarField->m_cubField && ( (int)pVarField->m_dubOffset == ( pubBlockOldCursor - pVarFieldBlockInfo->m_pubBlock ) ) )
|
|
{
|
|
pubBlockOldCursor += pVarField->m_cubField;
|
|
}
|
|
else
|
|
{
|
|
*pubBlockNewCursor++ = *pubBlockOldCursor++;
|
|
}
|
|
}
|
|
|
|
// put this field data at the end
|
|
Q_memcpy( pubBlockNewCursor, pvData, cubData );
|
|
|
|
// free the old block
|
|
if ( bFreeOnRealloc )
|
|
FreePv( pVarFieldBlockInfo->m_pubBlock );
|
|
|
|
// Update the block info
|
|
pVarFieldBlockInfo->m_cubBlock = cubBlockNew;
|
|
pVarFieldBlockInfo->m_pubBlock = ( uint8 * )pvBlockNew;
|
|
pVarFieldBlockInfo->m_cubBlockFree = 0;
|
|
|
|
// update this field
|
|
pVarField->m_cubField = cubData;
|
|
if ( cubData > 0 )
|
|
pVarField->m_dubOffset = static_cast<int>( pubBlockNewCursor - pVarFieldBlockInfo->m_pubBlock );
|
|
else
|
|
pVarField->m_dubOffset = 0;
|
|
|
|
// update other fields
|
|
for ( int iField = 0; iField < m_VecField.Count(); ++iField )
|
|
{
|
|
Field_t &field = m_VecField[iField];
|
|
if ( field.BIsVariableLength() )
|
|
{
|
|
// Needs updating
|
|
VarField_t *pVarFieldCur = ( VarField_t * )( ( uint8 * )pvRecord + field.m_dubOffset );
|
|
|
|
// Except the one we just changed
|
|
if ( pVarFieldCur == pVarField )
|
|
continue;
|
|
|
|
// And empty fields
|
|
if ( !pVarFieldCur->m_cubField )
|
|
continue;
|
|
|
|
if ( pVarFieldCur->m_dubOffset > dubOffsetOld )
|
|
pVarFieldCur->m_dubOffset -= cubFieldOld;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// all of the variable data is gone, so
|
|
// free the old block
|
|
if ( bFreeOnRealloc )
|
|
FreePv( pVarFieldBlockInfo->m_pubBlock );
|
|
|
|
// ... update the block info
|
|
pVarFieldBlockInfo->m_cubBlock = 0;
|
|
pVarFieldBlockInfo->m_pubBlock = NULL;
|
|
pVarFieldBlockInfo->m_cubBlockFree = 0;
|
|
|
|
// ... and update this field
|
|
pVarField->m_dubOffset = 0;
|
|
pVarField->m_cubField = cubData;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: If this is a variable-length record, and we just read it from
|
|
// a stream, then the var block is after the fixed-length part of the
|
|
// record. So, we need to update the record's pointer to reflect that
|
|
// Input: pvRecord - Beginning of the serialized record
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::FixupDeserializedRecord( void *pvRecord )
|
|
{
|
|
// Nothing to do if not a variable record
|
|
if ( !BHasVariableFields() )
|
|
return;
|
|
|
|
uint8 *pubRecord = ( uint8 * )pvRecord;
|
|
VarFieldBlockInfo_t *pVarBlockInfo = PVarFieldBlockInfoFromRecord( pvRecord );
|
|
pVarBlockInfo->m_pubBlock = pubRecord + m_cubRecord;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Initializes a new record with random data.
|
|
// Input: pubRecord - The record's in-memory data that we'll fill out
|
|
// unPrimaryIndex - Primary index of the record
|
|
// pbRealloced - Set to 'true' if the var-fields block for this record was reallocated
|
|
// (or allocated for the first time)
|
|
// bFreeOnRealloc - If true, we should Free() the var block after reallocating a new block
|
|
// (should be false if that block lives inside a NetPacket)
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::InitRecordRandom( uint8 *pubRecord, uint32 unPrimaryIndex, bool *pbVarBlockRealloced, bool bFreeVarBlockOnRealloc )
|
|
{
|
|
// Fill out each field in turn
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
bool bRealloced = false;
|
|
SetFieldRandom( pubRecord, iField, &bRealloced, bFreeVarBlockOnRealloc );
|
|
if ( bRealloced )
|
|
{
|
|
*pbVarBlockRealloced = true;
|
|
// if we just allocated it, we can free it next time we need to
|
|
bFreeVarBlockOnRealloc = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sets a single field of a record to a random value.
|
|
// Input: pubRecord - Where the record lives in memory
|
|
// iField - Which field to set
|
|
// pbRealloced - Set to 'true' if the var-fields block for this record was reallocated
|
|
// (or allocated for the first time)
|
|
// bFreeOnRealloc - If true, we should Free() the var block after reallocating a new block
|
|
// (should be false if that block lives inside a NetPacket)
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::SetFieldRandom( uint8 *pubRecord, int iField, bool *pbVarBlockRealloced, bool bFreeVarBlockOnRealloc )
|
|
{
|
|
Field_t &field = m_VecField[iField];
|
|
*pbVarBlockRealloced = false;
|
|
|
|
// Strings get random text
|
|
if ( k_EGCSQLType_String == field.m_EType )
|
|
{
|
|
// Generate up to cubLength - 1 chars
|
|
uint32 cch = UNRandFast() % field.m_cubLength;
|
|
uint32 ich = 0;
|
|
for ( ; ich < cch; ich++ )
|
|
*( ( char * ) pubRecord + field.m_dubOffset + ich ) = CHRandFast();
|
|
|
|
// Null termination
|
|
for ( ; ich < field.m_cubLength; ich++ )
|
|
*( ( char * ) pubRecord + field.m_dubOffset + ich ) = 0;
|
|
}
|
|
else if ( field.BIsVariableLength() )
|
|
{
|
|
// Need temp buffer to randomize before setting
|
|
// kept reasonably small to prevent spamming the console
|
|
uint8 rgubBuff[512];
|
|
uint32 cubData = UNRandFast() % sizeof(rgubBuff);
|
|
|
|
// For strings, put in (cubData-1) random characters (each randomly in the range [32,126])
|
|
// then a trailing NULL
|
|
if ( field.BIsStringType() )
|
|
{
|
|
uint32 ich = 0;
|
|
for ( ; ich < (cubData-1); ich++ )
|
|
rgubBuff[ich] = CHRandFast();
|
|
|
|
rgubBuff[ich] = 0;
|
|
}
|
|
else
|
|
{
|
|
// binary - just fill in random bytes
|
|
for ( uint32 iub = 0; iub < cubData; iub++ )
|
|
{
|
|
rgubBuff[iub] = ( uint8 )( UNRandFast() % 256 );
|
|
}
|
|
}
|
|
|
|
// Set the variable field in the record
|
|
BSetVarField( pubRecord, ( VarField_t * ) ( pubRecord + field.m_dubOffset ), rgubBuff, cubData, pbVarBlockRealloced, bFreeVarBlockOnRealloc );
|
|
}
|
|
// Binaries are filled with completely random bytes
|
|
else
|
|
{
|
|
for ( uint32 iub = 0; iub < field.m_cubLength; iub++ )
|
|
{
|
|
*( pubRecord + field.m_dubOffset + iub ) = ( uint8 ) ( UNRandFast() % 256 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns checksum of our contents
|
|
// Output : checksum
|
|
//-----------------------------------------------------------------------------
|
|
uint32 CSchema::CalcChecksum()
|
|
{
|
|
CRC32_t crc32;
|
|
CRC32_Init( &crc32 );
|
|
|
|
FOR_EACH_VEC( m_VecField, nField )
|
|
{
|
|
CRC32_ProcessBuffer( &crc32, &m_VecField[nField], sizeof( m_VecField[nField] ) );
|
|
}
|
|
|
|
// keep checksum for entire record info
|
|
CRC32_Final( &crc32 );
|
|
|
|
return (uint32)crc32;
|
|
}
|
|
|
|
|
|
void CSchema::AddIntField( char *pchName, char *pchSQLName, EGCSQLType eType, int cubSize )
|
|
{
|
|
int nExpectedSize = -1;
|
|
switch ( eType )
|
|
{
|
|
case k_EGCSQLType_int8:
|
|
nExpectedSize = 1;
|
|
break;
|
|
|
|
case k_EGCSQLType_int16:
|
|
nExpectedSize = 2;
|
|
break;
|
|
|
|
case k_EGCSQLType_int32:
|
|
case k_EGCSQLType_float:
|
|
nExpectedSize = 4;
|
|
break;
|
|
|
|
case k_EGCSQLType_int64:
|
|
case k_EGCSQLType_double:
|
|
nExpectedSize = 8;
|
|
break;
|
|
}
|
|
|
|
AssertMsg2( nExpectedSize != -1, "Unexpected EType in AddIntField: %d for column %s", eType, pchSQLName );
|
|
AssertMsg3( nExpectedSize == cubSize, "Unexpected size for in AddIntField for column %s: %d doesn't match %d ", pchSQLName, nExpectedSize, cubSize );
|
|
|
|
AddField( pchName, pchSQLName, eType, cubSize, 0 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a field from our intrinsic schema to this schema.
|
|
// Input: pchName - Name of the field
|
|
// pchSQLName - Name of the field in SQL database
|
|
// eType - Type of the field
|
|
// cubSize - Size of the field
|
|
// pfnCompare - Function used to compare fields (NULL if none specified)
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddField( char *pchName, char *pchSQLName, EGCSQLType eType, uint32 cubSize, int cchMaxLength )
|
|
{
|
|
int iFieldNew = m_VecField.AddToTail();
|
|
Field_t &field = m_VecField[iFieldNew];
|
|
|
|
field.m_EType = eType;
|
|
field.m_cubLength = cubSize;
|
|
field.m_nColFlags = 0;
|
|
Q_strncpy( field.m_rgchName, pchName, Q_ARRAYSIZE( field.m_rgchName ) );
|
|
Q_strncpy( field.m_rgchSQLName, pchSQLName, Q_ARRAYSIZE( field.m_rgchSQLName ) );
|
|
field.m_cchMaxLength = cchMaxLength;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as the primary index
|
|
// Input:
|
|
// bClustered - true to create a clustered index
|
|
// pchName - Name of the field to make primary index
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::PrimaryKey( bool bClustered, int nFillFactor, const char *pchName )
|
|
{
|
|
int iField = FindIField( pchName );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchName, m_rgchName );
|
|
|
|
Assert( m_nHasPrimaryKey == k_EPrimaryKeyTypeNone ); // may not already have a primary key defined
|
|
Assert( m_iPKIndex == k_iFieldNil );
|
|
|
|
// must not have been indexed in any way before
|
|
Assert( 0 == ( m_VecField[ iField ].m_nColFlags & ( k_nColFlagPrimaryKey | k_nColFlagIndexed | k_nColFlagUnique | k_nColFlagClustered ) ) );
|
|
|
|
// note that we have a single-column PK
|
|
m_nHasPrimaryKey = k_EPrimaryKeyTypeSingle;
|
|
|
|
// set our flags
|
|
m_VecField[ iField ].m_nColFlags |= ( k_nColFlagPrimaryKey | k_nColFlagIndexed | k_nColFlagUnique );
|
|
if ( bClustered )
|
|
m_VecField[ iField ].m_nColFlags |= k_nColFlagClustered;
|
|
|
|
// add to list of primary keys and remember the indexID
|
|
CUtlVector<int> vecColumns;
|
|
vecColumns.AddToTail( iField );
|
|
|
|
FieldSet_t vecIndex( true /* unique */ , bClustered, vecColumns, NULL );
|
|
vecIndex.SetFillFactor( nFillFactor );
|
|
m_iPKIndex = m_VecIndexes.AddToTail( vecIndex );
|
|
|
|
return m_iPKIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a set of fields as the primary index
|
|
// Input:
|
|
// bClustered - clustered index created if true
|
|
// nFillFactor - fill facto to use; 0 is database default
|
|
// pchName - Name of the field to make primary index
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::PrimaryKeys( bool bClustered, int nFillFactor, const char *pchNames )
|
|
{
|
|
Assert( pchNames != NULL ); // no bogus parameters, please
|
|
Assert( m_nHasPrimaryKey == k_EPrimaryKeyTypeNone ); // may not already have a primary key defined
|
|
Assert( m_iPKIndex == k_iFieldNil ); // no primary key defined
|
|
|
|
int nFlags = k_nColFlagPrimaryKey | k_nColFlagIndexed | k_nColFlagUnique;
|
|
if ( bClustered )
|
|
nFlags |= k_nColFlagClustered;
|
|
|
|
// go add all those fields as Indexed
|
|
int nNewIndex = AddIndexToFieldList( pchNames, NULL, nFlags, nFillFactor );
|
|
if ( nNewIndex != k_iFieldNil )
|
|
{
|
|
m_nHasPrimaryKey = k_EPrimaryKeyTypeMulti; // remember that we have multiple keys
|
|
m_iPKIndex = nNewIndex;
|
|
}
|
|
|
|
return nNewIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a set of fields as the primary index
|
|
// Input:
|
|
// pchName - Names of the fields for the primary index; comma-separated if multiple
|
|
// pchIndexName - Name of the index object (not in SQL)
|
|
// nFlags - flags for CColumnInfo on this object
|
|
// nFillFactor - fill facto to use; 0 is database default
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::AddIndexToFieldList( const char *pchNames, const char *pchIndexName, int nFlags, int nFillFactor )
|
|
{
|
|
// need a copy of string list since the argument is const and read-only
|
|
int cNamesLen = Q_strlen( pchNames ) + 1;
|
|
char* pchNamesCopy = (char*) PvAlloc( cNamesLen );
|
|
Q_strncpy( pchNamesCopy, pchNames, cNamesLen );
|
|
|
|
if (pchNames == NULL)
|
|
{
|
|
// not enough memory!
|
|
AssertFatal( false );
|
|
return k_iFieldNil;
|
|
}
|
|
|
|
CUtlVector<int> vecKeys;
|
|
|
|
char* pchCurrent = pchNamesCopy;
|
|
do
|
|
{
|
|
// find next token
|
|
char* pchEnd = strchr(pchCurrent, ',');
|
|
if ( pchEnd != NULL )
|
|
{
|
|
*pchEnd++ = 0;
|
|
}
|
|
|
|
// skip whitespace
|
|
while (isspace(*pchCurrent))
|
|
pchCurrent++;
|
|
|
|
// find the name; we expect a C++ name, not a SQL name
|
|
int iField = FindIField( pchCurrent );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchCurrent, m_rgchName );
|
|
|
|
// mark as a primary key
|
|
m_VecField[iField].m_nColFlags |= nFlags ;
|
|
|
|
// add it to our collection
|
|
vecKeys.AddToTail( iField );
|
|
|
|
// move past the end of this token in the string
|
|
pchCurrent = pchEnd;
|
|
} while ( pchCurrent != NULL );
|
|
|
|
// release our copy
|
|
FreePv(pchNamesCopy);
|
|
|
|
// create a fieldset with our list of indexes
|
|
// and add it to our indexes collection
|
|
bool bUnique = 0 != (nFlags & k_nColFlagUnique);
|
|
bool bClustered = 0 != (nFlags & k_nColFlagClustered);
|
|
FieldSet_t vecIndex( bUnique, bClustered, vecKeys, pchIndexName );
|
|
vecIndex.SetFillFactor( nFillFactor );
|
|
int iReturn = m_VecIndexes.AddToTail( vecIndex );
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as indexed.
|
|
// Input: pchName - Name of the field to index
|
|
// pchIndexName - Name of the index object (not in SQL)
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::IndexField( const char *pchIndexName, const char *pchName )
|
|
{
|
|
Assert( pchName != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// find the field by name
|
|
int iField = FindIField( pchName );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchName, m_rgchName );
|
|
|
|
// add an index to it
|
|
return AddIndexToFieldNumber( iField, pchIndexName, false /* Not clustered */ );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as indexed.
|
|
// Input: pchIndexName - Name of the index object (not in SQL)
|
|
// pchName - Name of the fields to index; comma separated if multiple
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::IndexFields( const char *pchIndexName, const char *pchNames )
|
|
{
|
|
Assert( pchNames != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// go add all those fields as Indexed
|
|
int nNewIndex = AddIndexToFieldList( pchNames, pchIndexName, k_nColFlagIndexed, 0 );
|
|
return nNewIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Includes a column (or columns) in an index for the INCLUDE clause
|
|
// Input: pchIndexName - Name of the index object (not in SQL)
|
|
// pchName - Name of the fields to index; comma separated if multiple
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddIncludedFields( const char *pchIndexName, const char *pchNames )
|
|
{
|
|
Assert( pchNames != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// find that index by name
|
|
int nIndexIndex = -1;
|
|
FOR_EACH_VEC( m_VecIndexes, i )
|
|
{
|
|
FieldSet_t &refSet = m_VecIndexes.Element(i);
|
|
const char *pstrMatch = refSet.GetIndexName();
|
|
if ( Q_stricmp( pstrMatch, pchIndexName ) == 0 )
|
|
{
|
|
nIndexIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// must have found it
|
|
AssertFatalMsg1( nIndexIndex != -1, "Index \"%s\" not found", pchIndexName );
|
|
FieldSet_t &refSet = m_VecIndexes.Element( nIndexIndex );
|
|
|
|
// need a copy of string list since the argument is const and read-only
|
|
int cNamesLen = Q_strlen( pchNames ) + 1;
|
|
char* pchNamesCopy = (char*) PvAlloc( cNamesLen );
|
|
Q_strncpy( pchNamesCopy, pchNames, cNamesLen );
|
|
|
|
char* pchCurrent = pchNamesCopy;
|
|
do
|
|
{
|
|
// find next token
|
|
char* pchEnd = strchr(pchCurrent, ',');
|
|
if ( pchEnd != NULL )
|
|
{
|
|
*pchEnd++ = 0;
|
|
}
|
|
|
|
// skip whitespace
|
|
while (isspace(*pchCurrent))
|
|
pchCurrent++;
|
|
|
|
// find the name; we expect a C++ name, not a SQL name
|
|
int iField = FindIField( pchCurrent );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchCurrent, m_rgchName );
|
|
|
|
// add it to our collection
|
|
refSet.AddIncludedColumn( iField );
|
|
|
|
// move past the end of this token in the string
|
|
pchCurrent = pchEnd;
|
|
} while ( pchCurrent != NULL );
|
|
|
|
// release our copy
|
|
FreePv( pchNamesCopy );
|
|
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as indexed.
|
|
// Input: pchIndexName - Name of the index object (not in SQL)
|
|
// pchName - Name of the fields to index; comma separated if multiple
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::UniqueFields( const char *pchIndexName, const char *pchNames )
|
|
{
|
|
Assert( pchNames != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// go add all those fields as Indexed
|
|
int nNewIndex = AddIndexToFieldList( pchNames, pchIndexName, k_nColFlagIndexed | k_nColFlagUnique, 0 );
|
|
return nNewIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field a having a clustered index.
|
|
// Input: pchName - Name of the field to index
|
|
// pchIndexName - Name of the index object (not in SQL)
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::ClusteredIndexField( int nFillFactor, const char *pchIndexName, const char *pchName )
|
|
{
|
|
Assert( pchName != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// can't previously have some other clustered index
|
|
FOR_EACH_VEC( m_VecIndexes, iIndex )
|
|
{
|
|
if ( m_VecIndexes[iIndex].IsClustered() )
|
|
{
|
|
AssertFatalMsg3( false, "On table %s, can't make index %s clustered because %s is already the clustered index\n",
|
|
m_rgchName, pchIndexName, m_VecIndexes[iIndex].GetIndexName() );
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// find the field by name
|
|
int iField = FindIField( pchName );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchName, m_rgchName );
|
|
|
|
// add an index to it
|
|
int iIndex = AddIndexToFieldNumber( iField, pchIndexName, true /* clustered */ );
|
|
m_VecIndexes[iIndex].SetFillFactor( nFillFactor );
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given set of fields as having a clustered index.
|
|
// Input: pchIndexName - Name of the index object (not in SQL)
|
|
// pchName - Name of the fields to index; comma separated if multiple
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::ClusteredIndexFields( int nFillFactor, const char *pchIndexName, const char *pchNames )
|
|
{
|
|
Assert( pchNames != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
// can't previously have some other clustered index
|
|
FOR_EACH_VEC( m_VecIndexes, iIndex )
|
|
{
|
|
if ( m_VecIndexes[iIndex].IsClustered() )
|
|
{
|
|
AssertFatalMsg3( false, "On table %s, can't make index %s clustered because %s is already the clustered index\n",
|
|
m_rgchName, pchIndexName, m_VecIndexes[iIndex].GetIndexName() );
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// go add all those fields as Indexed
|
|
int nNewIndex = AddIndexToFieldList( pchNames, pchIndexName, k_nColFlagClustered | k_nColFlagIndexed, nFillFactor );
|
|
return nNewIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddFullTextIndex( CSchemaFull *pSchemaFull, const char *pchCatalogName, const char *pchColumnName )
|
|
{
|
|
Assert( pchCatalogName != NULL );
|
|
Assert( pchColumnName != NULL );
|
|
|
|
// need a copy of string list since the argument is const and read-only
|
|
int cNamesLen = Q_strlen( pchColumnName ) + 1;
|
|
char* pchNamesCopy = (char*) PvAlloc( cNamesLen );
|
|
Q_strncpy( pchNamesCopy, pchColumnName, cNamesLen );
|
|
|
|
if ( pchNamesCopy == NULL )
|
|
{
|
|
// not enough memory!
|
|
AssertFatal( false );
|
|
return;
|
|
}
|
|
|
|
char* pchCurrent = pchNamesCopy;
|
|
do
|
|
{
|
|
// find next token
|
|
char* pchEnd = strchr(pchCurrent, ',');
|
|
if ( pchEnd != NULL )
|
|
{
|
|
*pchEnd++ = 0;
|
|
}
|
|
|
|
// skip whitespace
|
|
while (isspace(*pchCurrent))
|
|
pchCurrent++;
|
|
|
|
// find the name; we expect a C++ name, not a SQL name
|
|
int iField = FindIField( pchCurrent );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchCurrent, m_rgchName );
|
|
|
|
// add it to our collection
|
|
m_VecFullTextIndexes.AddToTail( iField );
|
|
|
|
// move past the end of this token in the string
|
|
pchCurrent = pchEnd;
|
|
} while ( pchCurrent != NULL );
|
|
|
|
// release our copy
|
|
FreePv(pchNamesCopy);
|
|
|
|
// make a note of the catalog we want
|
|
int nCatalogID = pSchemaFull->GetFTSCatalogByName( m_eSchemaCatalog, pchCatalogName );
|
|
AssertFatalMsg2( nCatalogID != -1, "Could not find fulltext catalog \"%s\" on table \"%s\"", pchCatalogName, m_rgchName );
|
|
m_nFullTextIndexCatalog = nCatalogID;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a field as indexed given its field number
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::AddIndexToFieldNumber( int iField, const char *pchIndexName, bool bClustered )
|
|
{
|
|
// mark the field as indexed
|
|
m_VecField[iField].m_nColFlags |= k_nColFlagIndexed;
|
|
|
|
// meant to be clustered?
|
|
if ( bClustered )
|
|
m_VecField[iField].m_nColFlags |= k_nColFlagClustered;
|
|
|
|
// add to list of indexes, and remember the indexID
|
|
CUtlVector<int> vecColumns;
|
|
vecColumns.AddToTail( iField );
|
|
|
|
// false: not unique
|
|
// false: not clustered
|
|
FieldSet_t vecIndex( false, bClustered, vecColumns, pchIndexName);
|
|
int iIndex = m_VecIndexes.AddToTail( vecIndex );
|
|
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as unique.
|
|
// Input: pchName - Name of the field to index
|
|
// pchIndexName - Name of the index object
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::UniqueField( const char *pchIndexName, const char *pchName )
|
|
{
|
|
Assert( pchName != NULL );
|
|
Assert( pchIndexName != NULL );
|
|
|
|
int iField = FindIField( pchName );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchName, m_rgchName );
|
|
|
|
m_VecField[iField].m_nColFlags |= ( k_nColFlagUnique | k_nColFlagIndexed );
|
|
|
|
// add to list of indexes, and remember the indexID
|
|
CUtlVector<int> vecColumns;
|
|
vecColumns.AddToTail( iField );
|
|
|
|
// true: unique
|
|
// false: not clustered
|
|
FieldSet_t vecIndex( true, false, vecColumns, pchIndexName );
|
|
int iIndex = m_VecIndexes.AddToTail( vecIndex );
|
|
|
|
return iIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Marks a given field as auto increment.
|
|
// Input: pchName - Name of the field
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AutoIncrementField( char *pchName )
|
|
{
|
|
int iField = FindIField( pchName );
|
|
AssertFatalMsg2( k_iFieldNil != iField, "Could not find index column \"%s\" on table \"%s\"", pchName, m_rgchName );
|
|
m_VecField[iField].m_nColFlags |= k_nColFlagAutoIncrement;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the field with a given name.
|
|
// Input: pchName - Name of the field to search for
|
|
// Output: Index of the matching field (k_iFieldNil if there isn't one)
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::FindIField( const char *pchName )
|
|
{
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
if ( 0 == Q_strncmp( pchName, m_VecField[iField].m_rgchName, k_cSQLObjectNameMax ) )
|
|
return iField;
|
|
}
|
|
|
|
return k_iFieldNil;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the field with a given SQL name.
|
|
// Input: pchName - Name of the field to search for
|
|
// Output: Index of the matching field (k_iFieldNil if there isn't one)
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::FindIFieldSQL( const char *pchName )
|
|
{
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
if ( 0 == Q_strncmp( pchName, m_VecField[iField].m_rgchSQLName, k_cSQLObjectNameMax ) )
|
|
return iField;
|
|
}
|
|
|
|
return k_iFieldNil;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different Schema to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddDeleteField( const char *pchFieldName )
|
|
{
|
|
DeleteField_t &deleteField = m_VecDeleteField[m_VecDeleteField.AddToTail()];
|
|
Q_strncpy( deleteField.m_rgchFieldName, pchFieldName, sizeof( deleteField.m_rgchFieldName ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different Schema to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddRenameField( const char *pchFieldNameOld, const char *pchFieldNameNew )
|
|
{
|
|
RenameField_t &renameField = m_VecRenameField[m_VecRenameField.AddToTail()];
|
|
Q_strncpy( renameField.m_rgchFieldNameOld, pchFieldNameOld, sizeof( renameField.m_rgchFieldNameOld ) );
|
|
renameField.m_iFieldDst = FindIField( pchFieldNameNew );
|
|
Assert( k_iFieldNil != renameField.m_iFieldDst );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different Schema to this one).
|
|
// Input: pchFieldNameOld - Name of the field in the old schema
|
|
// pchFieldNameMew - Name of the field in the new schema
|
|
// pfnAlterField - Function to translate data from the old format to
|
|
// the new
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddAlterField( const char *pchFieldNameOld, const char *pchFieldNameNew, PfnAlterField_t pfnAlterField )
|
|
{
|
|
Assert( pfnAlterField );
|
|
AlterField_t &alterField = m_VecAlterField[m_VecAlterField.AddToTail()];
|
|
Q_strncpy( alterField.m_rgchFieldNameOld, pchFieldNameOld, sizeof( alterField.m_rgchFieldNameOld ) );
|
|
alterField.m_iFieldDst = FindIField( pchFieldNameNew );
|
|
Assert( k_iFieldNil != alterField.m_iFieldDst );
|
|
alterField.m_pfnAlterFunc = pfnAlterField;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Figures out how to map a field from another Schema into us.
|
|
// First we check our conversion instructions to see if any apply,
|
|
// and then we look for a straightforward match.
|
|
// Input: pchFieldName - Name of the field we're trying to map
|
|
// piFieldDst - [Return] Index of the field to map it to
|
|
// ppfnAlterField - [Return] Optional function to convert data
|
|
// Output: true if we know what to do with this field (if false, the conversion
|
|
// is undefined and dangerous).
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchema::BCanConvertField( const char *pchFieldName, int *piFieldDst, PfnAlterField_t *ppfnAlterField )
|
|
{
|
|
*ppfnAlterField = NULL;
|
|
|
|
// Should this field be deleted?
|
|
for ( int iDeleteField = 0; iDeleteField < m_VecDeleteField.Count(); iDeleteField++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchFieldName, m_VecDeleteField[iDeleteField].m_rgchFieldName ) )
|
|
{
|
|
*piFieldDst = k_iFieldNil;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Should this field be renamed?
|
|
for ( int iRenameField = 0; iRenameField < m_VecRenameField.Count(); iRenameField++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchFieldName, m_VecRenameField[iRenameField].m_rgchFieldNameOld ) )
|
|
{
|
|
*piFieldDst = m_VecRenameField[iRenameField].m_iFieldDst;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Was this field altered?
|
|
for ( int iAlterField = 0; iAlterField < m_VecAlterField.Count(); iAlterField++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchFieldName, m_VecAlterField[iAlterField].m_rgchFieldNameOld ) )
|
|
{
|
|
*piFieldDst = m_VecAlterField[iAlterField].m_iFieldDst;
|
|
*ppfnAlterField = m_VecAlterField[iAlterField].m_pfnAlterFunc;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Find out which of our fields this field maps to (if it doesn't map
|
|
// to any of them, we don't know what to do with it).
|
|
*piFieldDst = FindIField( pchFieldName );
|
|
return ( k_iFieldNil != *piFieldDst );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the size to use when writing to a field.
|
|
//-----------------------------------------------------------------------------
|
|
int Field_t::CubFieldUpdateSize() const
|
|
{
|
|
switch ( m_EType )
|
|
{
|
|
case k_EGCSQLType_String:
|
|
case k_EGCSQLType_Blob:
|
|
case k_EGCSQLType_Image:
|
|
// Nobody should call this function for
|
|
// var-length fields
|
|
Assert( false );
|
|
return m_cubLength;
|
|
|
|
case k_EGCSQLType_int8:
|
|
case k_EGCSQLType_int16:
|
|
case k_EGCSQLType_int32:
|
|
case k_EGCSQLType_int64:
|
|
case k_EGCSQLType_float:
|
|
case k_EGCSQLType_double:
|
|
return m_cubLength;
|
|
|
|
default:
|
|
Assert(false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Tell whether or not a field is of string type.
|
|
//-----------------------------------------------------------------------------
|
|
bool Field_t::BIsStringType() const
|
|
{
|
|
return ( k_EGCSQLType_String == m_EType );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Tell whether or not the field is of variable-length type.
|
|
//-----------------------------------------------------------------------------
|
|
bool Field_t::BIsVariableLength() const
|
|
{
|
|
return ( k_EGCSQLType_String == m_EType ) || ( k_EGCSQLType_Blob == m_EType ) || ( k_EGCSQLType_Image == m_EType );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add a foreign key
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::AddFK( const char* pchName, const char* pchColumn, const char* pchParentTable, const char* pchParentColumn, EForeignKeyAction eOnDeleteAction, EForeignKeyAction eOnUpdateAction )
|
|
{
|
|
int iTail = m_VecFKData.AddToTail();
|
|
FKData_t &fkData = m_VecFKData[iTail];
|
|
|
|
Q_snprintf( fkData.m_rgchName, Q_ARRAYSIZE( fkData.m_rgchName ), "%s_%s", GetPchName(), pchName );
|
|
Q_strncpy( fkData.m_rgchParentTableName, pchParentTable, Q_ARRAYSIZE( fkData.m_rgchParentTableName ) );
|
|
fkData.m_eOnDeleteAction = eOnDeleteAction;
|
|
fkData.m_eOnUpdateAction = eOnUpdateAction;
|
|
|
|
// Now we need to split up the column name strings and add their data
|
|
FKColumnRelation_t colRelation;
|
|
Q_memset( &colRelation, 0, sizeof( FKColumnRelation_t ) );
|
|
uint iMyColumn = 0;
|
|
uint iParentColumn = 0;
|
|
uint iParentString = 0;
|
|
for( uint i=0; i<(uint)Q_strlen( pchColumn )+1; ++i )
|
|
{
|
|
if ( pchColumn[i] != ',' && pchColumn[i] != 0 )
|
|
{
|
|
colRelation.m_rgchCol[ iMyColumn++ ] = pchColumn[i];
|
|
}
|
|
else
|
|
{
|
|
Assert( Q_strlen( colRelation.m_rgchCol ) );
|
|
// Should have a matching column name in the parent string
|
|
while( iParentString < (uint)Q_strlen( pchParentColumn ) )
|
|
{
|
|
if ( pchParentColumn[iParentString] != ',' )
|
|
{
|
|
colRelation.m_rgchParentCol[ iParentColumn++ ] = pchParentColumn[iParentString];
|
|
++iParentString;
|
|
}
|
|
else
|
|
{
|
|
++iParentString;
|
|
break;
|
|
}
|
|
}
|
|
|
|
AssertMsg( Q_strlen( colRelation.m_rgchParentCol ), "Column counts for FK do not match between child/parent\n" );
|
|
fkData.m_VecColumnRelations.AddToTail( colRelation );
|
|
Q_memset( &colRelation, 0, sizeof( FKColumnRelation_t ) );
|
|
// Reset positions
|
|
iMyColumn = 0;
|
|
iParentColumn = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Caches the insert statement for each table so we don't need to
|
|
// generate it for each row we insert.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CSchema::GetInsertStatementText() const
|
|
{
|
|
if ( m_sInsertStatementText.IsEmpty() )
|
|
{
|
|
TSQLCmdStr sBuilder;
|
|
BuildInsertStatementText( &sBuilder, GetRecordInfo() );
|
|
m_sInsertStatementText.Set( sBuilder );
|
|
}
|
|
|
|
return m_sInsertStatementText;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Caches the insert via MERGE statement for each table so we don't need to
|
|
// generate it for each row we insert.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CSchema::GetMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert()
|
|
{
|
|
if ( m_sMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert.IsEmpty() )
|
|
{
|
|
TSQLCmdStr sBuilder;
|
|
BuildMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert( &sBuilder, GetRecordInfo() );
|
|
m_sMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert.Set( sBuilder );
|
|
}
|
|
|
|
return m_sMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Caches the insert via MERGE statement for each table so we don't need to
|
|
// generate it for each row we insert.
|
|
//-----------------------------------------------------------------------------
|
|
const char *CSchema::GetMergeStatementTextOnPKWhenNotMatchedInsert()
|
|
{
|
|
if ( m_sMergeStatementTextOnPKWhenNotMatchedInsert.IsEmpty() )
|
|
{
|
|
TSQLCmdStr sBuilder;
|
|
BuildMergeStatementTextOnPKWhenNotMatchedInsert( &sBuilder, GetRecordInfo() );
|
|
m_sMergeStatementTextOnPKWhenNotMatchedInsert.Set( sBuilder );
|
|
}
|
|
|
|
return m_sMergeStatementTextOnPKWhenNotMatchedInsert;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the number of foreign key constraints defined for the table
|
|
//-----------------------------------------------------------------------------
|
|
int CSchema::GetFKCount()
|
|
{
|
|
return m_VecFKData.Count();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get data for a foreign key by index (valid for 0...GetFKCount()-1)
|
|
//-----------------------------------------------------------------------------
|
|
FKData_t &CSchema::GetFKData( int iIndex )
|
|
{
|
|
return m_VecFKData[iIndex];
|
|
}
|
|
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Run a global validation pass on all of our data structures and memory
|
|
// allocations.
|
|
// Input: validator - Our global validator object
|
|
// pchName - Our name (typically a member var in our container)
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
// 1.
|
|
// Claim our memory
|
|
VALIDATE_SCOPE();
|
|
|
|
m_VecField.Validate( validator, "m_VecField" );
|
|
m_VecDeleteField.Validate( validator, "m_VecDeleteField" );
|
|
m_VecRenameField.Validate( validator, "m_VecRenameField" );
|
|
m_VecIndexes.Validate( validator, "m_VecIndexes" );
|
|
m_VecFullTextIndexes.Validate( validator, "m_VecFullTextIndexes" );
|
|
ValidateObj( m_VecFKData );
|
|
FOR_EACH_VEC( m_VecFKData, i )
|
|
{
|
|
ValidateObj( m_VecFKData[i] );
|
|
}
|
|
|
|
for ( int iIndex = 0; iIndex < m_VecIndexes.Count(); iIndex++ )
|
|
{
|
|
ValidateObj( m_VecIndexes[iIndex] );
|
|
}
|
|
|
|
ValidateObj( m_sInsertStatementText );
|
|
|
|
// 2.
|
|
// Validate that our fields make sense
|
|
#if defined(_DEBUG)
|
|
uint32 dubOffset = 0;
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
Assert( dubOffset == m_VecField[iField].m_dubOffset );
|
|
dubOffset += m_VecField[iField].m_cubLength;
|
|
}
|
|
#endif // defined(_DEBUG)
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Validates that a given record from our table is in a good state.
|
|
// Input: pubRecord - Record to validate
|
|
//-----------------------------------------------------------------------------
|
|
void CSchema::ValidateRecord( uint8 *pubRecord )
|
|
{
|
|
// Make sure each record is in a consistent state
|
|
for ( int iField = 0; iField < m_VecField.Count(); iField++ )
|
|
{
|
|
Field_t &field = m_VecField[iField];
|
|
|
|
// Ensure that strings are null-terminated, and that everything after the terminator is 0
|
|
if ( k_EGCSQLType_String == field.m_EType )
|
|
{
|
|
char *pchField = ( char * ) pubRecord + field.m_dubOffset;
|
|
Assert( 0 == pchField[field.m_cubLength - 1] );
|
|
for ( uint32 ich = 0; ich < field.m_cubLength; ich++ )
|
|
{
|
|
if ( 0 == pchField[ich] )
|
|
{
|
|
while ( ich < field.m_cubLength )
|
|
{
|
|
Assert( 0 == pchField[ich] );
|
|
ich++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
} // namespace GCSDK
|