source-engine/public/gcsdk/sqlaccess/schemafull.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================

#ifndef GCSCHEMAFULL_H
#define GCSCHEMAFULL_H
#ifdef _WIN32
#pragma once
#endif


namespace GCSDK
{


//-----------------------------------------------------------------------------
// SerSchemaFull
// This defines the binary serialization format for a CSchemaFull
//-----------------------------------------------------------------------------
struct SerSchemaFull_t
{
	enum EVersion
	{
		k_ECurrentVersion = 1,
	};

	int32 m_nVersion;		// version of serialization format 
	int32 m_cSchema;		// # of schema we contain
};


//-----------------------------------------------------------------------------
// CFTSCatalogInfo
// information about a full text search catalog object in our schema
//-----------------------------------------------------------------------------
class CFTSCatalogInfo 
{
public:
	enum ESchemaCatalog m_eCatalog;
	const char *m_pstrName;
	int m_nFileGroup;

	CFTSCatalogInfo()
		: m_pstrName( NULL ),
		m_eCatalog( k_ESchemaCatalogInvalid )
	{
	}

	~CFTSCatalogInfo()
	{
		free( (void*) m_pstrName);
	}

	CFTSCatalogInfo( const CFTSCatalogInfo &refOther )
	{
		m_eCatalog = refOther.m_eCatalog;
		m_nFileGroup = refOther.m_nFileGroup;
		if ( refOther.m_pstrName != NULL )
			m_pstrName = strdup( refOther.m_pstrName );
		else
			m_pstrName = NULL;
	}

#ifdef DBGFLAG_VALIDATE
	void Validate( CValidator &validator, const char *pchName )		// Validate our internal structures
	{
		validator.ClaimMemory( (void *) m_pstrName );
	}
#endif
};


//-----------------------------------------------------------------------------
// SchemaFull conversion instructions
// These specify various operations that can be performed when converting
// from one SchemaFull to another.
//-----------------------------------------------------------------------------
struct DeleteTable_t
{
	char m_rgchTableName[k_cSQLObjectNameMax];		// Name of the table to delete
};

struct RenameTable_t
{
	char m_rgchTableNameOld[k_cSQLObjectNameMax];	// Rename a table with this name
	int m_iTableDst;							// to this table
};


enum ETriggerType
{
	k_ETriggerType_Invalid,
	k_ETriggerType_After_Insert,
	k_ETriggerType_InsteadOf_Insert,
	k_ETriggerType_After_Delete,
	k_ETriggerType_InsteadOf_Delete,
	k_ETriggerType_After_Update,
	k_ETriggerType_InsteadOf_Update,
};

class CTriggerInfo
{
public:
	CTriggerInfo()
		: m_eTriggerType( k_ETriggerType_Invalid ),
		m_bMatched( false )
	{
	}

	// are these equal for identity?
	bool operator==( const CTriggerInfo& refOther ) const
	{
		if ( 0 != Q_stricmp( m_szTriggerTableName, refOther.m_szTriggerTableName ) )
			return false;
		if ( 0 != Q_stricmp( m_szTriggerName, refOther.m_szTriggerName ) )
			return false;

		// they're equal!
		return true;
	}

	// if the identity is the same, this will tell if text or type differs
	bool IsDifferent( const CTriggerInfo& refOther ) const
	{
		if ( m_eTriggerType != refOther.m_eTriggerType )
			return false;
		if ( m_strText != refOther.m_strText )
			return false;

		// they're equal!
		return true;
	}

	const char* GetTriggerTypeString() const
	{
		const char *pstrSQL = "~~ unknown trigger type syntax error ~~";

		switch ( m_eTriggerType )
		{
		case k_ETriggerType_After_Insert:
			pstrSQL = "AFTER INSERT";
			break;
		case k_ETriggerType_InsteadOf_Insert:
			pstrSQL = "INSTEAD OF INSERT";
			break;
		case k_ETriggerType_After_Delete:
			pstrSQL = "AFTER DELETE";
			break;
		case k_ETriggerType_InsteadOf_Delete:
			pstrSQL = "INSTEAD OF DELETE";
			break;
		case k_ETriggerType_After_Update:
			pstrSQL = "AFTER UPDATE";
			break;
		case k_ETriggerType_InsteadOf_Update:
			pstrSQL = "INSTEAD OF UPDATE";
			break;

		default:
		case k_ETriggerType_Invalid:
			/* initialize is fine, thanks */
			break;
		}

		return pstrSQL;
	}

	bool m_bMatched;								// got matched during schema convert
	ETriggerType m_eTriggerType;					// what kinda trigger is this?
	ESchemaCatalog m_eSchemaCatalog;				// catalog where this trigger lives
	char m_szTriggerName[k_cSQLObjectNameMax];		// name of the trigger object
	char m_szTriggerTableName[k_cSQLObjectNameMax];	// name of the table hosting this trigger
	CUtlString m_strText;							// text of the trigger

	// Validate our internal structures
#ifdef DBGFLAG_VALIDATE
	void Validate( CValidator &validator, const char *pchName )
	{
		m_strText.Validate( validator, pchName );
	}
#endif
};


//-----------------------------------------------------------------------------
// CSchemaFull
// This defines the schema for the entire data store.  It's essentially just
// a collection of CSchema, which define the schema for individual tables.
//-----------------------------------------------------------------------------
class CSchemaFull
{
public:
	// Constructors & destructors
	CSchemaFull();
	~CSchemaFull();

	void Uninit();

	// add a new schema and return its pointer.
	CSchema *AddNewSchema( int iTable, ESchemaCatalog eCatalog, const char *pstrName )
	{
		CSchema &refNewSchema = m_VecSchema[m_VecSchema.AddToTail()];
		refNewSchema.SetName( pstrName );
		refNewSchema.SetESchemaCatalog( eCatalog );
		SetITable( &refNewSchema, iTable );
		return &refNewSchema;
	}


	// Accessors
	int GetCSchema() const { return m_VecSchema.Count(); }
	CSchema &GetSchema( int iSchema ) { return m_VecSchema[iSchema]; }
	uint32 GetCheckSum() const { return m_unCheckSum; }
	const char *GetDefaultSchemaNameForCatalog( ESchemaCatalog eCatalog );

	uint8 *GetPubScratchBuffer( );
	uint32 GetCubScratchBuffer() const { return m_cubScratchBuffer; }

	// Makes sure that a generated intrinsic schema is consistent
	void CheckSchema( CSchema *pSchema, int cField, uint32 cubRecord );

	// Find the table with a given name (returns -1 if not found)
	int FindITable( const char *pchName );
	const char *PchTableFromITable( int iTable );

	// Helper functions for recording schema conversion operations
	void AddDeleteTable( const char *pchTableName );
	void AddRenameTable( const char *pchTableNameOld, const char *pchTableNameNew );
	void AddDeleteField( const char *pchTableName, const char *pchFieldName );
	void AddRenameField( const char *pchTableName, const char *pchFieldNameOld, const char *pchFieldNameNew );
	void AddAlterField( const char *pchTableName, const char *pchFieldNameOld, const char *pchFieldNameNew, PfnAlterField_t pfnAlterField );

	// declare that a trigger is on a table
	void AddTrigger( ESchemaCatalog eCatalog, const char *pchTableName, const char *pchTriggerName, ETriggerType eTriggerType, const char *pchTriggerText );

	// Schema conversion helper: figure out what table to map a table from a different schema to
	bool BCanConvertTable( const char *pchTableSrc, int *piTableDst );

	// full text catalogs
	void AddFullTextCatalog( enum ESchemaCatalog eCatalog, const char *pstrCatalogName, int nFileGroup );
	int GetFTSCatalogByName( enum ESchemaCatalog eCatalog, const char *pstrCatalogName );
	void EnableFTS( enum ESchemaCatalog eCatalog );
	int GetCFTSCatalogs() const { return m_vecFTSCatalogs.Count(); }
	const CFTSCatalogInfo &  GetFTSCatalogInfo( int nIndex ) const { return m_vecFTSCatalogs[nIndex]; }

	const CUtlVector< CTriggerInfo> & GetTriggerInfos( ) const { return m_VecTriggers; }

	// is the given schema catalog FTS enabled?
	bool GetFTSEnabled( enum ESchemaCatalog eCatalog );

	void Validate( CValidator &validator, const char *pchName );		// Validate our internal structures

	// sets tableID on CSchema, checking that it is not a duplicate
	void SetITable( CSchema* pSchema, int iTable );
	void FinishInit();						// Recalculates some internal fields
private:
	CUtlConstString m_strDefaultSchemaName;

	CUtlVector< CSchema > m_VecSchema;		// Schema for tables in all catalogs
	CUtlVector< CTriggerInfo > m_VecTriggers;		// list of triggers in all catalogs

	// which schema catalogs have FTS enabled?
	CUtlMap< ESchemaCatalog, bool > m_mapFTSEnabled;

	// list of catalogs; each is marked with the schema where it lives.
	CUtlVector< CFTSCatalogInfo > m_vecFTSCatalogs;

	uint32 m_unCheckSum;					// A simple checksum of our contents

	// SchemaFull conversion instructions
	CUtlVector<DeleteTable_t> m_VecDeleteTable;
	CUtlVector<RenameTable_t> m_VecRenameTable;

	uint8 *m_pubScratchBuffer;				// Big enough to hold any record or sparse record in this schemafull
	uint32 m_cubScratchBuffer;					// Size of the scratch buffer
};

extern CSchemaFull & GSchemaFull();

} // namespace GCSDK
#endif // GCSCHEMAFULL_H