Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

602 lines
21 KiB

5 years ago
//========= 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