410 lines
14 KiB
C++
410 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
namespace GCSDK
|
|
{
|
|
CSchemaFull g_SchemaFull;
|
|
CSchemaFull & GSchemaFull()
|
|
{
|
|
return g_SchemaFull;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CSchemaFull::CSchemaFull()
|
|
{
|
|
m_pubScratchBuffer = NULL;
|
|
m_cubScratchBuffer = 0;
|
|
m_unCheckSum = 0;
|
|
|
|
m_mapFTSEnabled.SetLessFunc( DefLessFunc( enum ESchemaCatalog ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Destructor
|
|
//-----------------------------------------------------------------------------
|
|
CSchemaFull::~CSchemaFull()
|
|
{
|
|
Uninit();
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Call this after you've finished setting up the SchemaFull (either
|
|
// by loading it or by in GenerateIntrinsic). It calculates our checksum
|
|
// and allocates our scratch buffer.
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::FinishInit()
|
|
{
|
|
// Calculate our checksum
|
|
m_unCheckSum = 0;
|
|
|
|
for ( int iSchema = 0; iSchema < m_VecSchema.Count(); iSchema++ )
|
|
m_unCheckSum += m_VecSchema[iSchema].CalcChecksum();
|
|
|
|
// Allocate our scratch buffer
|
|
Assert( NULL == m_pubScratchBuffer );
|
|
// Include some slop for field IDs and sizes in a sparse record
|
|
// 2k is way overkill but still no big deal
|
|
m_cubScratchBuffer = k_cubRecordMax + 2048;
|
|
m_pubScratchBuffer = ( uint8 * ) malloc( m_cubScratchBuffer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Call this after you've finished setting up the SchemaFull (either
|
|
// by loading it or by in GenerateIntrinsic). It calculates our checksum
|
|
// and allocates our scratch buffer.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void CSchemaFull::SetITable( CSchema* pSchema, int iTable )
|
|
{
|
|
// make sure we don't have this schema anywhere already
|
|
for ( int iSchema = 0; iSchema < m_VecSchema.Count(); iSchema++ )
|
|
{
|
|
if ( pSchema != &m_VecSchema[iSchema] )
|
|
AssertFatalMsg( m_VecSchema[iSchema].GetITable() != iTable, "Duplicate iTable in schema definition.\n" );
|
|
}
|
|
|
|
// set the pSchema object
|
|
pSchema->SetITable( iTable );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Uninits the schema. Need to call this explicitly before app shutdown
|
|
// on static instances of this object, as the CSchema objects
|
|
// point to memory in static memory pools which may destruct
|
|
// before static instances of this object.
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::Uninit()
|
|
{
|
|
m_VecSchema.RemoveAll();
|
|
if ( NULL != m_pubScratchBuffer )
|
|
{
|
|
free( m_pubScratchBuffer );
|
|
m_pubScratchBuffer = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the scratch buffer. It is large enough to handle any
|
|
// record, sparse or otherwise
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
uint8* CSchemaFull::GetPubScratchBuffer( )
|
|
{
|
|
return m_pubScratchBuffer;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This is used during the generation of our intrinsic schema. We've
|
|
// added a new schema to ourselves, and we need to make sure that it
|
|
// matches the corresponding C class.
|
|
// Input: pSchema - Schema to check
|
|
// cField - Number of fields the schema should contain.
|
|
// cubRecord - Size of a record in the schema
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::CheckSchema( CSchema *pSchema, int cField, uint32 cubRecord )
|
|
{
|
|
// We generate our structures and our schema using macros that operate on the
|
|
// same source. We check a couple of things to make sure that they're properly in sync.
|
|
|
|
// This will fail if the schema's definition specifies the wrong iTable
|
|
if ( pSchema != &m_VecSchema[pSchema->GetITable()] )
|
|
{
|
|
EmitError( SPEW_SQL, "Table %s has a bad iTable\n", pSchema->GetPchName() );
|
|
}
|
|
|
|
// This will fail if there are missing lines in the schema definition
|
|
if ( pSchema->GetCField() != cField )
|
|
{
|
|
EmitError( SPEW_SQL, "Badly formed table %s (blank line in schema def?)\n", pSchema->GetPchName() );
|
|
AssertFatal( false );
|
|
}
|
|
|
|
// This is unlikely to fail. It indicates some kind of size mismatch (maybe a packing problem?)
|
|
if ( pSchema->CubRecordFixed() != cubRecord )
|
|
{
|
|
// You may hit this if END_FIELDDATA_HAS_VAR_FIELDS is not used properly
|
|
EmitError( SPEW_SQL, "Table %s has an inconsistent size (class = %d, schema = %d)\n",
|
|
pSchema->GetPchName(), cubRecord, pSchema->CubRecordFixed() );
|
|
AssertFatal( false );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the table with a given name.
|
|
// Input: pchName - Name of the table to search for
|
|
// Output: Index of the matching table ( k_iTableNil if there isn't one)
|
|
//-----------------------------------------------------------------------------
|
|
int CSchemaFull::FindITable( const char *pchName )
|
|
{
|
|
for ( int iSchema = 0; iSchema < m_VecSchema.Count(); iSchema++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchName, m_VecSchema[iSchema].GetPchName() ) )
|
|
return iSchema;
|
|
}
|
|
|
|
return k_iTableNil;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Finds the table with a given iTable (iSchema)
|
|
// Input: iTable -
|
|
// Output: NULL or a const char * to the name (for temporary use only)
|
|
//-----------------------------------------------------------------------------
|
|
const char * CSchemaFull::PchTableFromITable( int iTable )
|
|
{
|
|
if ( iTable < 0 || iTable >= m_VecSchema.Count() )
|
|
return NULL;
|
|
else
|
|
return m_VecSchema[ iTable ].GetPchName();
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddFullTextCatalog( enum ESchemaCatalog eCatalog, const char *pstrCatalogName, int nFileGroup )
|
|
{
|
|
CFTSCatalogInfo info;
|
|
info.m_eCatalog = eCatalog;
|
|
info.m_nFileGroup = nFileGroup;
|
|
info.m_pstrName = strdup(pstrCatalogName);
|
|
|
|
m_vecFTSCatalogs.AddToTail( info );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
int CSchemaFull::GetFTSCatalogByName( enum ESchemaCatalog eCatalog, const char *pstrCatalogName )
|
|
{
|
|
int nIndex = -1;
|
|
FOR_EACH_VEC( m_vecFTSCatalogs, i )
|
|
{
|
|
CFTSCatalogInfo &refInfo = m_vecFTSCatalogs[ i ];
|
|
if ( 0 == Q_stricmp( pstrCatalogName, refInfo.m_pstrName ) )
|
|
{
|
|
nIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return nIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: turn on FTS for the named schema catalog. Called by the
|
|
// InitIntrinsic() function.
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::EnableFTS( enum ESchemaCatalog eCatalog )
|
|
{
|
|
// mark it enabled in the map
|
|
m_mapFTSEnabled.Insert( eCatalog, true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: is FTS enabled for the supplied schema catalog?
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchemaFull::GetFTSEnabled( enum ESchemaCatalog eCatalog )
|
|
{
|
|
int iEntry = m_mapFTSEnabled.Find( eCatalog );
|
|
if ( iEntry == m_mapFTSEnabled.InvalidIndex() )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different SchemaFull to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddDeleteTable( const char *pchTableName )
|
|
{
|
|
DeleteTable_t &deleteTable = m_VecDeleteTable[m_VecDeleteTable.AddToTail()];
|
|
Q_strncpy( deleteTable.m_rgchTableName, pchTableName, sizeof( deleteTable.m_rgchTableName ) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different SchemaFull to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddRenameTable( const char *pchTableNameOld, const char *pchTableNameNew )
|
|
{
|
|
RenameTable_t &renameTable = m_VecRenameTable[m_VecRenameTable.AddToTail()];
|
|
Q_strncpy( renameTable.m_rgchTableNameOld, pchTableNameOld, sizeof( renameTable.m_rgchTableNameOld ) );
|
|
renameTable.m_iTableDst = FindITable( pchTableNameNew );
|
|
Assert( k_iTableNil != renameTable.m_iTableDst );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different SchemaFull to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddDeleteField( const char *pchTableName, const char *pchFieldName )
|
|
{
|
|
int iSchema = FindITable( pchTableName );
|
|
AssertFatal( k_iTableNil != iSchema );
|
|
|
|
m_VecSchema[iSchema].AddDeleteField( pchFieldName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different SchemaFull to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddRenameField( const char *pchTableName, const char *pchFieldNameOld, const char *pchFieldNameNew )
|
|
{
|
|
int iSchema = FindITable( pchTableName );
|
|
AssertFatal( k_iTableNil != iSchema );
|
|
|
|
m_VecSchema[iSchema].AddRenameField( pchFieldNameOld, pchFieldNameNew );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Adds a schema conversion instruction (for use in converting from
|
|
// a different SchemaFull to this one).
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddAlterField( const char *pchTableName, const char *pchFieldNameOld, const char *pchFieldnameNew, PfnAlterField_t pfnAlterField )
|
|
{
|
|
int iSchema = FindITable( pchTableName );
|
|
AssertFatal( k_iTableNil != iSchema );
|
|
|
|
m_VecSchema[iSchema].AddAlterField( pchFieldNameOld, pchFieldnameNew, pfnAlterField );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Add a trigger to the desired schema
|
|
//-----------------------------------------------------------------------------
|
|
void CSchemaFull::AddTrigger( ESchemaCatalog eCatalog, const char *pchTableName, const char *pchTriggerName, ETriggerType eTriggerType, const char *pchTriggerText )
|
|
{
|
|
CTriggerInfo trigger;
|
|
trigger.m_eTriggerType = eTriggerType;
|
|
trigger.m_eSchemaCatalog = eCatalog;
|
|
Q_strncpy( trigger.m_szTriggerName, pchTriggerName, Q_ARRAYSIZE( trigger.m_szTriggerName ) );
|
|
Q_strncpy( trigger.m_szTriggerTableName, pchTableName, Q_ARRAYSIZE( trigger.m_szTriggerTableName ) );
|
|
trigger.m_strText = pchTriggerText;
|
|
|
|
// add it to our list
|
|
m_VecTriggers.AddToTail( trigger );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Figures out how to map a table from another SchemaFull into us.
|
|
// First we check our conversion instructions to see if any apply,
|
|
// and then we look for a straightforward match.
|
|
// Input: pchTableName - Name of the table we're trying to map
|
|
// piTableDst - [Return] Index of the table to map it to
|
|
// Output: true if we know what to do with this table (if false, the conversion
|
|
// is undefined and dangerous).
|
|
//-----------------------------------------------------------------------------
|
|
bool CSchemaFull::BCanConvertTable( const char *pchTableName, int *piTableDst )
|
|
{
|
|
// Should this table be deleted?
|
|
for ( int iDeleteTable = 0; iDeleteTable < m_VecDeleteTable.Count(); iDeleteTable++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchTableName, m_VecDeleteTable[iDeleteTable].m_rgchTableName ) )
|
|
{
|
|
*piTableDst = k_iTableNil;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Should this table be renamed?
|
|
for ( int iRenameTable = 0; iRenameTable < m_VecRenameTable.Count(); iRenameTable++ )
|
|
{
|
|
if ( 0 == Q_strcmp( pchTableName, m_VecRenameTable[iRenameTable].m_rgchTableNameOld ) )
|
|
{
|
|
*piTableDst = m_VecRenameTable[iRenameTable].m_iTableDst;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Find out which of our tables this table maps to (if it doesn't map
|
|
// to any of them, we don't know what to do with it).
|
|
*piTableDst = FindITable( pchTableName );
|
|
return ( k_iTableNil != *piTableDst );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Gets the default SQL schema name for a catalog
|
|
//-----------------------------------------------------------------------------
|
|
const char *CSchemaFull::GetDefaultSchemaNameForCatalog( ESchemaCatalog eCatalog )
|
|
{
|
|
// For all catalogs it's actually the same
|
|
if ( m_strDefaultSchemaName.IsEmpty() )
|
|
{
|
|
m_strDefaultSchemaName.Set( CFmtStr( "App%u", GGCBase()->GetAppID() ) );
|
|
}
|
|
|
|
return m_strDefaultSchemaName.Get();
|
|
}
|
|
|
|
|
|
#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 CSchemaFull::Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
|
|
ValidateObj( m_VecSchema );
|
|
for ( int iSchema = 0; iSchema < m_VecSchema.Count(); iSchema++ )
|
|
{
|
|
ValidateObj( m_VecSchema[iSchema] );
|
|
}
|
|
|
|
ValidateObj( m_VecDeleteTable );
|
|
ValidateObj( m_VecRenameTable );
|
|
|
|
ValidateObj( m_mapFTSEnabled );
|
|
|
|
ValidateObj( m_vecFTSCatalogs );
|
|
FOR_EACH_VEC( m_vecFTSCatalogs, i )
|
|
{
|
|
ValidateObj( m_vecFTSCatalogs[i] );
|
|
}
|
|
|
|
ValidateObj( m_VecTriggers );
|
|
FOR_EACH_VEC( m_VecTriggers, i )
|
|
{
|
|
ValidateObj( m_VecTriggers[i] );
|
|
}
|
|
|
|
validator.ClaimMemory( m_pubScratchBuffer );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
} // namespace GCSDK
|