602 lines
21 KiB
C++
602 lines
21 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================
|
|
|
|
#ifndef GCSCHEMA_H
|
|
#define GCSCHEMA_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
namespace GCSDK
|
|
{
|
|
const int k_nColFlagIndexed = 0x0001; // this column is indexed.
|
|
const int k_nColFlagUnique = 0x0002; // this column has a uniqueness constraint - creates implicit index
|
|
const int k_nColFlagPrimaryKey = 0x0004; // this column has a primary key constraint - creates implicit uniqueness constraint & implicit index
|
|
const int k_nColFlagAutoIncrement = 0x0008; // this column can have it's values created implicitly by the sql counter
|
|
const int k_nColFlagClustered = 0x0010; // this column is clustered
|
|
|
|
const int k_nColFlagAllConstraints = k_nColFlagUnique | k_nColFlagPrimaryKey;
|
|
|
|
class CRecordInfo;
|
|
struct VarFieldBlockInfo_t;
|
|
struct VarFieldBlockInfo_t;
|
|
struct Field_t;
|
|
struct VarField_t;
|
|
|
|
// Function type for altering field types when converting schemas
|
|
typedef void (* PfnAlterField_t )( void *pvDest, const void *pvSrc );
|
|
|
|
// EPrimaryKeyType
|
|
// This shows if a table has a primary key and, if so, if it has multiple columns
|
|
// or not.
|
|
enum EPrimaryKeyType
|
|
{
|
|
k_EPrimaryKeyTypeNone = 0, // none at all
|
|
k_EPrimaryKeyTypeSingle, // single-column primary key
|
|
k_EPrimaryKeyTypeMulti, // multi-column primary key
|
|
};
|
|
|
|
|
|
// EWipePolicy
|
|
// This tells us if a table is supposed to be wiped before all tests,
|
|
// before all tests except stress tests, or not to be wiped before tests.
|
|
enum EWipePolicy
|
|
{
|
|
k_EWipePolicyPreserveAlways = 0, // don't wipe table
|
|
k_EWipePolicyPreserveForStress = 1, // preserve for stress tests, wipe before regular tests
|
|
k_EWipePolicyWipeForAllTests = 2, // wipe table prior to all tests
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Field
|
|
// This defines the schema of a single field in one of our tables.
|
|
//-----------------------------------------------------------------------------
|
|
struct Field_t
|
|
{
|
|
bool BGetIntData( uint8 *pubRecord, uint64 *pulRet ) const;
|
|
bool BGetFloatData( uint8 *pubRecord, float *fRet ) const;
|
|
bool SetIntData( uint8 *pubRecord, uint64 ulValue ) const;
|
|
// Not all fields are updated wholly at a time
|
|
int CubFieldUpdateSize() const;
|
|
// Handy helpers - complex fields like "rolling unique" are
|
|
// still binary
|
|
bool BIsStringType() const;
|
|
|
|
bool BIsVariableLength() const;
|
|
|
|
// Members that get serialized
|
|
EGCSQLType m_EType; // Field type
|
|
uint32 m_cubLength; // Length of the field in bytes
|
|
uint32 m_cchMaxLength; // maximum length of the field in characters
|
|
char m_rgchName[k_cSQLObjectNameMax]; // Human-readable name of this field
|
|
char m_rgchSQLName[k_cSQLObjectNameMax]; // SQL name of this field
|
|
|
|
// Members that don't get serialized
|
|
uint32 m_nColFlags; // k_nColFlag* bits for this field
|
|
uint32 m_dubOffset; // Offset of this field from beginning of record
|
|
};
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Information about a foreign key relationship defined on a table
|
|
struct FKColumnRelation_t
|
|
{
|
|
char m_rgchCol[k_cSQLObjectNameMax+1];
|
|
char m_rgchParentCol[k_cSQLObjectNameMax+1];
|
|
|
|
FKColumnRelation_t()
|
|
{
|
|
Q_memset( m_rgchCol, 0, Q_ARRAYSIZE( m_rgchCol ) );
|
|
Q_memset( m_rgchParentCol, 0, Q_ARRAYSIZE( m_rgchParentCol ) );
|
|
}
|
|
|
|
bool operator==( const FKColumnRelation_t &other ) const
|
|
{
|
|
if ( Q_stricmp( m_rgchCol, other.m_rgchCol ) )
|
|
return false;
|
|
if ( Q_stricmp( m_rgchParentCol, other.m_rgchParentCol ) )
|
|
return false;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
struct FKData_t
|
|
{
|
|
char m_rgchName[k_cSQLObjectNameMax+1];
|
|
char m_rgchParentTableName[k_cSQLObjectNameMax+1];
|
|
CCopyableUtlVector<FKColumnRelation_t> m_VecColumnRelations;
|
|
EForeignKeyAction m_eOnDeleteAction;
|
|
EForeignKeyAction m_eOnUpdateAction;
|
|
|
|
FKData_t()
|
|
{
|
|
Q_memset( m_rgchName, 0, Q_ARRAYSIZE( m_rgchName ) );
|
|
Q_memset( m_rgchParentTableName, 0, Q_ARRAYSIZE( m_rgchParentTableName ) );
|
|
m_eOnDeleteAction = k_EForeignKeyActionNoAction;
|
|
m_eOnUpdateAction = k_EForeignKeyActionNoAction;
|
|
}
|
|
|
|
bool operator==( const FKData_t &other ) const
|
|
{
|
|
if ( Q_stricmp( m_rgchName, other.m_rgchName ) )
|
|
return false;
|
|
|
|
if ( Q_stricmp( m_rgchParentTableName, other.m_rgchParentTableName ) )
|
|
return false;
|
|
|
|
if ( m_eOnDeleteAction != other.m_eOnDeleteAction || m_eOnUpdateAction != other.m_eOnUpdateAction )
|
|
return false;
|
|
|
|
FOR_EACH_VEC( m_VecColumnRelations, i )
|
|
{
|
|
bool bFoundInOther = false;
|
|
const FKColumnRelation_t &cols = m_VecColumnRelations[i];
|
|
|
|
FOR_EACH_VEC( other.m_VecColumnRelations, j )
|
|
{
|
|
const FKColumnRelation_t &colsOther = other.m_VecColumnRelations[j];
|
|
if ( cols == colsOther )
|
|
{
|
|
bFoundInOther = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bFoundInOther )
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
// Validate our internal structures
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_VecColumnRelations );
|
|
}
|
|
#endif
|
|
|
|
};
|
|
|
|
|
|
#pragma pack( push, 1 )
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SerSchema
|
|
// Defines the binary serialization format for a schema.
|
|
//-----------------------------------------------------------------------------
|
|
struct SerSchema_t
|
|
{
|
|
uint32 m_cub; // Size of the whole schema (including header and fields)
|
|
int32 m_iTable; // Our table's iTable
|
|
char m_rgchName[k_cSQLObjectNameMax]; // Human-readable name of this table
|
|
int16 m_cField; // # of fields in the schema (int16 for backward-compatibility reasons)
|
|
int16 m_ETableGroup; // Our table's TableGroup (int16 for backward-compatibility reasons) - OBSOLETE
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SerField
|
|
// Defines the binary serialization format for a field in a schema
|
|
// Note that certain fields are missing from this because we only use serialized
|
|
// schemas for schema mapping. Fields that only affect runtime behavior (like
|
|
// indexing) are always defined by the intrinsic schema.
|
|
//-----------------------------------------------------------------------------
|
|
struct SerField_t
|
|
{
|
|
int32 m_EType; // Field type
|
|
uint32 m_cubLength; // Length of field data in bytes
|
|
// For rolling fields, high 16 bits are the
|
|
// size of each element
|
|
|
|
char m_rgchName[k_cSQLObjectNameMax];// Human-readable name of this field
|
|
char m_rgchSQLName[k_cSQLObjectNameMax]; // SQL name of this field
|
|
};
|
|
|
|
#pragma pack( pop )
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Schema conversion instructions
|
|
// These specify various operations that can be performed when converting
|
|
// from one Schema to another.
|
|
//-----------------------------------------------------------------------------
|
|
struct DeleteField_t
|
|
{
|
|
char m_rgchFieldName[k_cSQLObjectNameMax]; // Name of the field to delete
|
|
};
|
|
|
|
struct RenameField_t
|
|
{
|
|
char m_rgchFieldNameOld[k_cSQLObjectNameMax]; // Rename a field with this name
|
|
int m_iFieldDst; // to this field
|
|
};
|
|
|
|
struct AlterField_t
|
|
{
|
|
char m_rgchFieldNameOld[k_cSQLObjectNameMax]; // Name of field in the old schema
|
|
int m_iFieldDst; // iField of it in the new
|
|
PfnAlterField_t m_pfnAlterFunc; // Function to translate the data
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// FieldSet_t describes a collection of fields in an index, as well as
|
|
// attributes of the index itself
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class FieldSet_t
|
|
{
|
|
public:
|
|
FieldSet_t( bool bUnique, bool bClustered, const CUtlVector<int>& vecFields, const char* pstrIndexName )
|
|
: m_bClustered( bClustered ), m_bUnique( bUnique )
|
|
{
|
|
m_VecFields = vecFields;
|
|
|
|
// zero means to use the server default
|
|
m_nFillFactor = 0;
|
|
|
|
// null name is allowed for primary keys
|
|
if ( pstrIndexName != NULL )
|
|
Q_strncpy( m_szIndexName, pstrIndexName, Q_ARRAYSIZE( m_szIndexName ) );
|
|
else
|
|
m_szIndexName[0] = 0;
|
|
}
|
|
|
|
FieldSet_t( )
|
|
{
|
|
}
|
|
|
|
~FieldSet_t( )
|
|
{
|
|
}
|
|
|
|
FieldSet_t( const FieldSet_t &refOther )
|
|
{
|
|
DoAssignment( refOther );
|
|
}
|
|
|
|
FieldSet_t& operator=( const FieldSet_t &refOther )
|
|
{
|
|
DoAssignment( refOther );
|
|
return *this;
|
|
}
|
|
|
|
void DoAssignment( const FieldSet_t &refOther )
|
|
{
|
|
m_VecFields = refOther.m_VecFields;
|
|
m_VecIncluded = refOther.m_VecIncluded;
|
|
m_bClustered = refOther.m_bClustered;
|
|
m_bUnique = refOther.m_bUnique;
|
|
m_nFillFactor = refOther.m_nFillFactor;
|
|
Q_strncpy( m_szIndexName, refOther.m_szIndexName, Q_ARRAYSIZE( m_szIndexName ) );
|
|
|
|
}
|
|
|
|
// get count of fields in this index
|
|
int GetCount() const
|
|
{
|
|
return m_VecFields.Count();
|
|
}
|
|
|
|
// get count of included fields in this index
|
|
int GetIncludedCount() const
|
|
{
|
|
return m_VecIncluded.Count();
|
|
}
|
|
|
|
void AddIncludedColumn( int nIndex )
|
|
{
|
|
m_VecIncluded.AddToTail( nIndex );
|
|
}
|
|
|
|
void AddIncludedColumns( const CUtlVector<int> &refVec )
|
|
{
|
|
m_VecIncluded.AddVectorToTail( refVec );
|
|
}
|
|
|
|
// get a particular field ID
|
|
// the returned index is into the VecFields of the associated schema
|
|
int GetField( int nIndex ) const
|
|
{
|
|
return m_VecFields[ nIndex ];
|
|
}
|
|
|
|
int GetIncludedField( int nIndex ) const
|
|
{
|
|
return m_VecIncluded[ nIndex ];
|
|
}
|
|
|
|
// is this index clustered?
|
|
bool IsClustered() const
|
|
{
|
|
return m_bClustered;
|
|
}
|
|
|
|
// is this index unique?
|
|
bool IsUnique() const
|
|
{
|
|
return m_bUnique;
|
|
}
|
|
|
|
void SetClustered( bool bIsClustered )
|
|
{
|
|
m_bClustered = bIsClustered;
|
|
}
|
|
|
|
void SetFillFactor( int nFactor )
|
|
{
|
|
Assert( nFactor >= 0 && nFactor <= 100 );
|
|
m_nFillFactor = nFactor;
|
|
}
|
|
|
|
int GetFillFactor( ) const
|
|
{
|
|
return m_nFillFactor;
|
|
}
|
|
|
|
const char* GetIndexName() const
|
|
{
|
|
return m_szIndexName;
|
|
}
|
|
|
|
// determine if this fieldset is equal to the other one
|
|
static bool CompareFieldSets( const FieldSet_t& refThis, CRecordInfo* pRecordInfoThis,
|
|
const FieldSet_t& refOther, CRecordInfo* pRecordInfoOther );
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
// Validate our internal structures
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
m_VecFields.Validate( validator, "m_VecFields" );
|
|
m_VecIncluded.Validate( validator, "m_VecIncluded" );
|
|
}
|
|
#endif
|
|
|
|
private:
|
|
CUtlVector<int> m_VecFields; // ids of fields; indexes into m_VecFields of CSchema for a table
|
|
CUtlVector<int> m_VecIncluded; // ids of included fields
|
|
int m_nFillFactor; // fill factor for the index; zero means to use the server's default
|
|
char m_szIndexName[k_cSQLObjectNameMax]; // name of this index
|
|
bool m_bClustered:1; // is this index clustered?
|
|
bool m_bUnique:1; // is this index unique?
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum ESchemaCatalog
|
|
{
|
|
k_ESchemaCatalogInvalid = -1,
|
|
k_ESchemaCatalogMain = 0, // main GC catalog
|
|
k_ESchemaCatalogOGS = 4, // operational game stats
|
|
};
|
|
|
|
extern const char* PchNameFromESchemaCatalog( ESchemaCatalog e );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CSchema
|
|
// This defines the schema for a single table. The schema essentially defines
|
|
// what's in the table (ie, field 0 is a 32 char string called "Name", etc.)
|
|
// The schema is in charge of manipulating individual records within the table.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CSchemaFull;
|
|
|
|
class CSchema
|
|
{
|
|
public:
|
|
|
|
// Constructors & destructors
|
|
CSchema();
|
|
~CSchema();
|
|
|
|
// Recalculates field offsets and maximum record size.
|
|
// Must be called after changing schema.
|
|
void CalcOffsets();
|
|
|
|
// called to make final calculations when all fields/indexes/etc have been added and the schema is ready to be used
|
|
void PrepareForUse();
|
|
|
|
// Sizing information
|
|
uint32 CubSerialSchema() const { return( sizeof( SerSchema_t ) + m_VecField.Count() * sizeof( SerField_t ) ); }
|
|
|
|
// Size of total fixed-length portion of record
|
|
uint32 CubRecordFixed() const { return( m_cubRecord ); }
|
|
|
|
// Size of the total variable-length portion of record (zero if no var-length fields)
|
|
uint32 CubRecordVariable( const void *pvRecord ) const;
|
|
|
|
// Does this record have variable-length fields?
|
|
bool BHasVariableFields() const { return m_bHasVarFields; }
|
|
|
|
VarFieldBlockInfo_t* PVarFieldBlockInfoFromRecord( const void *pvRecord ) const;
|
|
|
|
// Access field data - fixed or variable (may return NULL/0 for empty var field)
|
|
bool BGetFieldData( const void *pvRecord, int iField, uint8 **ppubField, uint32 *pcubField ) const;
|
|
bool BSetFieldData( void *pvRecord, int iField, uint8 *pubField, uint32 cubField, bool *pbVarBlockRealloced );
|
|
|
|
bool BGetVarField( const void *pvRecord, const VarField_t *pVarField, uint8 **ppubField, uint32 *pcubField ) const;
|
|
bool BSetVarField( void *pvRecord, VarField_t *pVarField, const void *pvData, uint32 cubData, bool *pbRealloced, bool bFreeOnRealloc );
|
|
|
|
// Adjust var-block pointer, if present, to point just after the fixed part of the record
|
|
void FixupDeserializedRecord( void *pvRecord );
|
|
|
|
// Render a record in text format
|
|
void RenderRecord( uint8 *pubRecord );
|
|
void RenderField( uint8 *pubRecord, int iField, int cchBuffer, char *pchBuffer );
|
|
|
|
// Accessors
|
|
void SetITable( int iTable ) { m_iTable = iTable; }
|
|
int GetITable() const { return m_iTable; }
|
|
int GetCField() const { return m_VecField.Count(); }
|
|
void SetReportingInterval( int nInterval ) { m_nReportingInterval = nInterval; }
|
|
int GetReportingInterval( ) const { return m_nReportingInterval; }
|
|
Field_t &GetField( int iField ) { return m_VecField[iField]; }
|
|
const Field_t &GetField( int iField ) const { return m_VecField[iField]; }
|
|
VarField_t *GetPVarField( void *pvRecord, int iField ) { return ( VarField_t * )( ( uint8 * ) pvRecord + m_VecField[iField].m_dubOffset ); }
|
|
void SetName( const char *pchName ) { Q_strncpy( m_rgchName, pchName, sizeof( m_rgchName ) ); }
|
|
const char *GetPchName() const { return m_rgchName; }
|
|
const FieldSet_t& GetPKFields() { Assert( m_iPKIndex != -1 ); return GetIndexes()[m_iPKIndex]; }
|
|
int GetPKIndex() const { return m_iPKIndex; }
|
|
const CUtlVector<FieldSet_t>& GetIndexes() { return m_VecIndexes; }
|
|
const CUtlVector<int>& GetFTSColumns() { return m_VecFullTextIndexes; }
|
|
int GetFTSIndexCatalog() const { return m_nFullTextIndexCatalog; }
|
|
|
|
ESchemaCatalog GetESchemaCatalog() const { return m_eSchemaCatalog; }
|
|
void SetESchemaCatalog( ESchemaCatalog eSchemaCatalog ) { m_eSchemaCatalog = eSchemaCatalog; }
|
|
|
|
// If cRecordMax is non-zero, this is a rolling table that only
|
|
// holds on to cRecordMax records at most.
|
|
void SetCRecordMax( int cRecordMax ) { m_cRecordMax = cRecordMax; }
|
|
int GetCRecordMax() const { return m_cRecordMax; }
|
|
|
|
// Is this table for TESTs only?
|
|
void SetBTestTable( bool bTestTable ) { m_bTestTable = bTestTable; }
|
|
bool GetBTestTable() const { return m_bTestTable; }
|
|
|
|
// Randomly init a record or field to random values
|
|
void InitRecordRandom( uint8 *pubRecord, uint32 unPrimaryIndex, bool *pbVarBlockRealloced, bool bFreeVarBlockOnRealloc );
|
|
void SetFieldRandom( uint8 *pubRecord, int iField, bool *pbVarBlockRealloced, bool bFreeVarBlockOnRealloc );
|
|
|
|
// Checksum the schema
|
|
uint32 CalcChecksum();
|
|
|
|
// pre-allocate space in the field array
|
|
void EnsureFieldCount( int cFields )
|
|
{
|
|
m_VecField.EnsureCapacity( cFields );
|
|
}
|
|
|
|
// This adds a field from our intrinsic schema to us
|
|
void AddField( char *pchName, char *pchSQLName, EGCSQLType eType, uint32 cubSize, int cchMaxLength );
|
|
void AddIntField( char *pchName, char *pchSQLName, EGCSQLType eType, int cubSize );
|
|
|
|
// We want to make a particular field the primary key
|
|
int PrimaryKey( bool bClustered, int nFillFactor, const char *pchName );
|
|
|
|
// we want to make a particular list of fields the primary key
|
|
int PrimaryKeys( bool bClustered, int nFillFactor, const char *pchNames );
|
|
|
|
// We want to index a particular field by name
|
|
int IndexField( const char *pchName, const char *pchIndexName );
|
|
|
|
// We want to index a particular list of fields in a group
|
|
int IndexFields( const char *pchIndexName, const char *pchNames );
|
|
|
|
// We want a certain index to additionally include a list of fields
|
|
void AddIncludedFields( const char *pchIndexName, const char *pchNames );
|
|
|
|
// We want to unique index a particular list of fields in a group
|
|
int UniqueFields( const char *pchIndexName, const char *pchNames );
|
|
|
|
// add a full-text index to the given column
|
|
void AddFullTextIndex( CSchemaFull *pSchemaFull, const char *pchCatalogName, const char *pchColumnName );
|
|
|
|
// We want to index a particular field by field number
|
|
// (field number is an index into the m_VecField array)
|
|
int AddIndexToFieldNumber( int iField, const char *pchIndexName, bool bClustered );
|
|
|
|
// We want to index a particular set of fields
|
|
// pchNames includes the names, separated by commas, of each field
|
|
int AddIndexToFieldList( const char *pchNames, const char *pchIndexName, int nFlags, int nFillFactor );
|
|
|
|
// We want a unique index on a particular field
|
|
int UniqueField( const char *pchName, const char *pchIndexName );
|
|
|
|
// We want to have a clustered index on a particular field by name
|
|
int ClusteredIndexField( int nFillFactor, const char *pchName, const char *pchIndexName );
|
|
|
|
// We want to index a particular list of fields in a group
|
|
int ClusteredIndexFields( int nFillFactor, const char *pchIndexName, const char *pchNames );
|
|
|
|
// We want an autoinc on a particular field
|
|
void AutoIncrementField( char *pchName );
|
|
|
|
// catalog on which we'll enable FTS
|
|
void EnableFTS( ESchemaCatalog eCatalog );
|
|
|
|
// adds a full text catalog with the given name on the identified fileset
|
|
void AddFullTextCatalog( ESchemaCatalog eCatalog, const char *pstrCatalogName, const char *pstrFileGroupName );
|
|
|
|
// Adds a FK on the table
|
|
void AddFK( const char* pchName, const char* pchColumn, const char* pchParentTable, const char* pchParentColumn, EForeignKeyAction eOnDeleteAction, EForeignKeyAction eOnUpdateAction );
|
|
|
|
// Access FK data
|
|
int GetFKCount();
|
|
FKData_t &GetFKData( int iIndex );
|
|
|
|
void SetTestWipePolicy( EWipePolicy policy ) { m_wipePolicy = policy; }
|
|
EWipePolicy GetTestWipePolicy() const { return m_wipePolicy; }
|
|
|
|
void SetBAllowWipeTableInProd( bool bVal ) { m_bAllowWipeInProd = bVal; }
|
|
bool BAllowWipeTableInProd() const { return m_bAllowWipeInProd; }
|
|
|
|
void SetPrepopulatedTable( ) { m_bPrepopulatedTable = true; }
|
|
bool BPrepopulatedTable( ) const { return m_bPrepopulatedTable; }
|
|
|
|
// Find the field with a given name (returns k_iFieldNil if not found)
|
|
int FindIField( const char *pchName );
|
|
int FindIFieldSQL( const char *pchName );
|
|
|
|
// Helper functions for recording schema conversion operations
|
|
void AddDeleteField( const char *pchFieldName );
|
|
void AddRenameField( const char *pchFieldNameOld, const char *pchFieldNameNew );
|
|
void AddAlterField( const char *pchFieldNameOld, const char *pchFieldNameNew, PfnAlterField_t pfnAlterField );
|
|
|
|
// Schema conversion helper: figure out what field to map a field from a different schema to
|
|
bool BCanConvertField( const char *pchFieldSrc, int *piFieldDst, PfnAlterField_t *ppfnAlterField );
|
|
|
|
CRecordInfo *GetRecordInfo() { return m_pRecordInfo; }
|
|
const CRecordInfo *GetRecordInfo() const { return m_pRecordInfo; }
|
|
|
|
void Validate( CValidator &validator, const char *pchName ); // Validate our internal structures
|
|
void ValidateRecord( uint8 *pubRecord ); // Validate a record that uses our schema
|
|
|
|
// cached queries
|
|
const char *GetInsertStatementText() const;
|
|
const char *GetMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert();
|
|
const char *GetMergeStatementTextOnPKWhenNotMatchedInsert();
|
|
|
|
private:
|
|
int m_iTable; // The index of our table
|
|
int m_iPKIndex; // index into of m_VecIndexes of our PK index; k_iFieldNil if no PK
|
|
char m_rgchName[k_cSQLObjectNameMax]; // Name of this table
|
|
CUtlVector<Field_t> m_VecField; // All the fields that make up the schema
|
|
CUtlVector<FieldSet_t> m_VecIndexes; // vector of all fields in all indexes
|
|
int m_cRecordMax; // Max # records in the table (for rolling tables)
|
|
bool m_bTestTable; // Table exists only for tests
|
|
bool m_bAllowWipeInProd; // should we allow WipeTable operations on this table in the beta/public universe?
|
|
EWipePolicy m_wipePolicy; // should this table be wiped between all tests, no tests, or non-stress tests?
|
|
bool m_bHasVarFields; // True if this table has variable-length fields
|
|
bool m_bPrepopulatedTable; // true if this table is pre-populated
|
|
EPrimaryKeyType m_nHasPrimaryKey; // what kind of PK do we have, if any?
|
|
CRecordInfo *m_pRecordInfo; // The record description corresponding to this schema. (Similar info, record description is new form, have both for a while during DS->SQL switch)
|
|
CUtlVector<int> m_VecFullTextIndexes; // vector of indexes into m_VecField of fields covered by this table's full-text index.
|
|
int m_nFullTextIndexCatalog; // index of catalog to use for creating full-text indexes
|
|
CUtlVector<FKData_t> m_VecFKData; // data on foreign keys for this schema object
|
|
|
|
uint32 m_cubRecord; // Binary record length
|
|
int m_nReportingInterval; // reporting interval of this table if stats; 0 if not stats
|
|
ESchemaCatalog m_eSchemaCatalog; // what catalog does this table live in?
|
|
|
|
// Schema conversion instructions
|
|
CUtlVector<DeleteField_t> m_VecDeleteField;
|
|
CUtlVector<RenameField_t> m_VecRenameField;
|
|
CUtlVector<AlterField_t> m_VecAlterField;
|
|
|
|
// Cached queries
|
|
mutable CUtlString m_sInsertStatementText; // Cached insert statement for the table
|
|
CUtlString m_sMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert; // Cached insert or update via MERGE statement for the table
|
|
CUtlString m_sMergeStatementTextOnPKWhenNotMatchedInsert; // Cached insert via MERGE statement for the table
|
|
};
|
|
|
|
} // namespace GCSDK
|
|
#endif // GCSCHEMA_H
|