1HEADmaster

9 files changed, 8158 insertions, 0 deletions

diff --git a/gcsdk/sqlaccess/columnset.cpp b/gcsdk/sqlaccess/columnset.cpp
new file mode 100644
index 0000000..4798aa1
--- /dev/null
+++ b/gcsdk/sqlaccess/columnset.cpp
@@ -0,0 +1,368 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Sets of columns in SQL queries
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "stdafx.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+namespace GCSDK
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructs a column set with no columns in it
+//-----------------------------------------------------------------------------
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo )
+: m_pRecordInfo( pRecordInfo )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructs a column set with a single column in it
+// Inputs:	nColumn - the column to add
+//-----------------------------------------------------------------------------
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.AddToTail( col1 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 2 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 3 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3, int col4 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 4 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+	m_vecColumns.AddToTail( col4 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3, int col4, int col5 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 5 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+	m_vecColumns.AddToTail( col4 );
+	m_vecColumns.AddToTail( col5 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3, int col4, int col5, int col6 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 6 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+	m_vecColumns.AddToTail( col4 );
+	m_vecColumns.AddToTail( col5 );
+	m_vecColumns.AddToTail( col6 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3, int col4, int col5, int col6, int col7 )
+	: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 7 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+	m_vecColumns.AddToTail( col4 );
+	m_vecColumns.AddToTail( col5 );
+	m_vecColumns.AddToTail( col6 );
+	m_vecColumns.AddToTail( col7 );
+}
+
+CColumnSet::CColumnSet( const CRecordInfo *pRecordInfo, int col1, int col2, int col3, int col4, int col5, int col6, int col7, int col8 )
+: m_pRecordInfo( pRecordInfo )
+{
+	m_vecColumns.EnsureCapacity( 8 );
+	m_vecColumns.AddToTail( col1 );
+	m_vecColumns.AddToTail( col2 );
+	m_vecColumns.AddToTail( col3 );
+	m_vecColumns.AddToTail( col4 );
+	m_vecColumns.AddToTail( col5 );
+	m_vecColumns.AddToTail( col6 );
+	m_vecColumns.AddToTail( col7 );
+	m_vecColumns.AddToTail( col8 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy constructor
+//-----------------------------------------------------------------------------
+CColumnSet::CColumnSet( const CColumnSet & rhs )
+{
+	MEM_ALLOC_CREDIT_("CColumnSet");
+	m_vecColumns.CopyArray( rhs.m_vecColumns.Base(), rhs.m_vecColumns.Count() );
+	m_pRecordInfo = rhs.m_pRecordInfo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Assignment operator
+//-----------------------------------------------------------------------------
+CColumnSet & CColumnSet::operator=( const CColumnSet & rhs )
+{
+	MEM_ALLOC_CREDIT_("CColumnSet");
+	m_vecColumns.CopyArray( rhs.m_vecColumns.Base(), rhs.m_vecColumns.Count() );
+	m_pRecordInfo = rhs.m_pRecordInfo;
+	return *this;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Addition operator. lhs ColumnSet will be a union of the two
+//	ColumnSets
+//-----------------------------------------------------------------------------
+CColumnSet & CColumnSet::operator+=( const CColumnSet & rhs )
+{
+	Assert( this->GetRecordInfo() == rhs.GetRecordInfo() );
+	FOR_EACH_COLUMN_IN_SET( rhs, i )
+	{
+		BAddColumn( rhs.GetColumn( i ) );
+	}
+
+	return *this;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Addition operator. Returns a union of lhs and rhs
+//-----------------------------------------------------------------------------
+const CColumnSet CColumnSet::operator+( const CColumnSet & rhs ) const
+{
+	return CColumnSet( *this ) += rhs;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a column to the set if it is 
+// Inputs:	nColumn - THe column to add
+//-----------------------------------------------------------------------------
+void CColumnSet::BAddColumn( int nColumn )
+{
+	if( nColumn >= 0 && nColumn < m_pRecordInfo->GetNumColumns() )
+	{
+		//not sure best way to handle the 'is already set case'
+		if( !IsSet( nColumn ) )
+			m_vecColumns.AddToTail( nColumn );
+	}
+	else
+	{
+		AssertMsg3( false, "Attempting to set an out of range column on schema type %s, %d (of %d)", GetRecordInfo()->GetName(), nColumn, m_pRecordInfo->GetNumColumns() );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Removes a column from the set
+// Inputs:	nColumn - THe column to remove
+//-----------------------------------------------------------------------------
+void CColumnSet::BRemoveColumn( int nColumn )
+{
+	m_vecColumns.FindAndRemove( nColumn );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if a column is in the set
+// Inputs:	nColumn - THe column to test
+//-----------------------------------------------------------------------------
+bool CColumnSet::IsSet( int nColumn ) const
+{
+	int nIndex = m_vecColumns.Find( nColumn );
+	return m_vecColumns.IsValidIndex( nIndex );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the number of columns in the set
+//-----------------------------------------------------------------------------
+uint32 CColumnSet::GetColumnCount() const
+{
+	return m_vecColumns.Count();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the column index of the Nth column in the set
+// Inputs:	nIndex - the position in the set to return a column index for.
+//-----------------------------------------------------------------------------
+int CColumnSet::GetColumn( int nIndex ) const
+{
+	return m_vecColumns[nIndex];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a CColumnInfo object for the nth column in the set
+// Inputs:	nIndex - the position in the set to return a column info for.
+//-----------------------------------------------------------------------------
+const CColumnInfo & CColumnSet::GetColumnInfo( int nIndex ) const
+{
+	return m_pRecordInfo->GetColumnInfo( GetColumn( nIndex ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Empties the column set
+//-----------------------------------------------------------------------------
+void CColumnSet::MakeEmpty()
+{
+	m_vecColumns.RemoveAll();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes the column set be the full set of all columns in the record info
+//-----------------------------------------------------------------------------
+void CColumnSet::MakeFull()
+{
+	MakeEmpty();
+	const int nNumColumns = m_pRecordInfo->GetNumColumns();
+	m_vecColumns.EnsureCapacity( nNumColumns );
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		//do a direct add to avoid the exponential cost since we know we won't have conflicts
+		m_vecColumns.AddToTail( nColumn );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes the column set be the full set of all insertable columns in 
+//			the record info
+//-----------------------------------------------------------------------------
+void CColumnSet::MakeInsertable()
+{
+	MakeEmpty();
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		const CColumnInfo & columnInfo = m_pRecordInfo->GetColumnInfo( nColumn );
+		if( columnInfo.BIsInsertable() )
+		{
+			//do a direct add to avoid the exponential cost since we know we won't have conflicts
+			m_vecColumns.AddToTail( nColumn );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes the column set be the full set of all noninsertable columns in 
+//			the record info
+//-----------------------------------------------------------------------------
+void CColumnSet::MakeNoninsertable()
+{
+	MakeEmpty();
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		const CColumnInfo & columnInfo = m_pRecordInfo->GetColumnInfo( nColumn );
+		if( !columnInfo.BIsInsertable() )
+		{
+			//do a direct add to avoid the exponential cost since we know we won't have conflicts
+			m_vecColumns.AddToTail( nColumn );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes the column set be the full set of all primary key columns in 
+//			the record info
+//-----------------------------------------------------------------------------
+void CColumnSet::MakePrimaryKey()
+{
+	MakeEmpty();
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		const CColumnInfo & columnInfo = m_pRecordInfo->GetColumnInfo( nColumn );
+		if( columnInfo.BIsPrimaryKey() )
+		{
+			//do a direct add to avoid the exponential cost since we know we won't have conflicts
+			m_vecColumns.AddToTail( nColumn );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Makes the column set be the full set of all primary key columns in 
+//			the record info
+//-----------------------------------------------------------------------------
+void CColumnSet::MakeInverse( const CColumnSet & columnSet )
+{
+	MakeEmpty();
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		if( !columnSet.IsSet( nColumn ) )
+		{
+			//do a direct add to avoid the exponential cost since we know we won't have conflicts
+			m_vecColumns.AddToTail( nColumn );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// determines if the current column set has all fields set. Useful for detection of new columns being added to the schema
+//-----------------------------------------------------------------------------
+bool CColumnSet::BAreAllFieldsSet() const
+{
+	for( int nColumn = 0; nColumn < m_pRecordInfo->GetNumColumns(); nColumn++ )
+	{
+		if( !IsSet( nColumn ) )
+			return false;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a Column Set which is the inverse of the given column set
+// STATIC - Difference from MakeInverse is that it has a return value
+//-----------------------------------------------------------------------------
+CColumnSet CColumnSet::Inverse( const CColumnSet & columnSet )
+{
+	CColumnSet set( columnSet.GetRecordInfo() );
+	set.MakeInverse( columnSet );
+	return set;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Claims the memory for CColumnSet
+//-----------------------------------------------------------------------------
+#ifdef DBGFLAG_VALIDATE
+void CColumnSet::Validate( CValidator &validator, const char *pchName )
+{
+	// these are INSIDE the function instead of outside so the interface 
+	// doesn't change
+	VALIDATE_SCOPE();
+
+	ValidateObj( m_vecColumns );
+}
+#endif
+
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/record.cpp b/gcsdk/sqlaccess/record.cpp
new file mode 100644
index 0000000..6812b50
--- /dev/null
+++ b/gcsdk/sqlaccess/record.cpp
@@ -0,0 +1,856 @@
+//========= 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
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CRecordBase::~CRecordBase()
+{
+	Cleanup();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy constructor
+// Input:	that -			CRecord to copy from
+//-----------------------------------------------------------------------------
+CRecordBase::CRecordBase( const CRecordBase &that )
+{
+	*this = that;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Assignment operator - COPIES the record data
+// Input:	that -			CRecord to copy from
+//-----------------------------------------------------------------------------
+CRecordBase& CRecordBase::operator = ( const CRecordBase & that )
+{
+	Assert( GetITable() == that.GetITable() );
+
+	// COPY that record
+	Copy( that );
+
+	return *this;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copies the data in the record. This is overridden by CRecordVar and
+//			CRecordExternal
+// Input:	that -			CRecord to copy from
+//-----------------------------------------------------------------------------
+void CRecordBase::Copy( const CRecordBase & that )
+{
+	Cleanup();
+	Q_memcpy( PubRecordFixed(), that.PubRecordFixed(), GetPSchema()->CubRecordFixed() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the record info for this record's schema
+//-----------------------------------------------------------------------------
+const CRecordInfo *CRecordBase::GetPRecordInfo() const
+{
+	return GetPSchema()->GetRecordInfo();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copies the data in the var record.
+// Input:	that -			CRecord to copy from
+//-----------------------------------------------------------------------------
+void CRecordVar::Copy( const CRecordBase & baseThat )
+{
+	const CRecordVar & that = (const CRecordVar &)baseThat;
+
+	// COPY that record
+	Cleanup();
+	m_pSchema = that.m_pSchema;
+	Q_memcpy( PubRecordFixed(), that.PubRecordFixed(), GetPSchema()->CubRecordFixed() );
+
+	SetFlag( k_EAllocatedVarBlock, false );
+	if ( VarFieldBlockInfo_t *pVarBlockInfo = GetPSchema()->PVarFieldBlockInfoFromRecord(	PubRecordFixed() ) )
+	{
+		if ( pVarBlockInfo->m_cubBlock )
+		{
+			void *pvNewBlock = malloc( pVarBlockInfo->m_cubBlock );
+			Q_memcpy( pvNewBlock, pVarBlockInfo->m_pubBlock, pVarBlockInfo->m_cubBlock );
+			pVarBlockInfo->m_pubBlock = ( uint8 * )pvNewBlock;
+			SetFlag( k_EAllocatedVarBlock, true );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copies the data in the var record.
+// Input:	that -			CRecord to copy from
+//-----------------------------------------------------------------------------
+void CRecordExternal::Copy( const CRecordBase & baseThat )
+{
+	const CRecordExternal & that = (const CRecordExternal &)baseThat;
+
+	Cleanup();
+	m_pSchema = that.m_pSchema;
+
+	m_pubRecordFixedExternal = ( uint8 * )malloc( m_pSchema->CubRecordFixed() );
+	Q_memcpy( m_pubRecordFixedExternal, that.PubRecordFixed(), m_pSchema->CubRecordFixed() );
+	SetFlag( k_EAllocatedFixed, true );
+
+	SetFlag( k_EAllocatedVarBlock, false );
+	if ( VarFieldBlockInfo_t *pVarBlockInfo = m_pSchema->PVarFieldBlockInfoFromRecord(	PubRecordFixed() ) )
+	{
+		if ( pVarBlockInfo->m_cubBlock )
+		{
+			void *pvNewBlock = malloc( pVarBlockInfo->m_cubBlock );
+			Q_memcpy( pvNewBlock, pVarBlockInfo->m_pubBlock, pVarBlockInfo->m_cubBlock );
+			pVarBlockInfo->m_pubBlock = ( uint8 * )pvNewBlock;
+			SetFlag( k_EAllocatedVarBlock, true );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Initialize to an empty record
+// Input:	pSchema -			Schema for the record this will hold
+//-----------------------------------------------------------------------------
+void CRecordExternal::Init( CSchema *pSchema )
+{
+	Cleanup();
+	m_pSchema = pSchema;
+	m_pubRecordFixedExternal = ( uint8 * )malloc( m_pSchema->CubRecordFixed() );
+	Q_memset( m_pubRecordFixedExternal, 0, m_pSchema->CubRecordFixed() );
+	SetFlag( k_EAllocatedFixed, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Initialize pointing to a record expanded in memory
+// Input:	pSchema -			Schema for the record this will hold
+//			pubRecord -			Pointer to fixed record data
+//			bTakeOwnership -	Should we delete the record when destroyed
+// Output:	Size of the record's data
+//-----------------------------------------------------------------------------
+int CRecordBase::InitFromBytes( uint8 *pubRecord )
+{
+	Cleanup();
+	
+	Q_memcpy( PubRecordFixed(), pubRecord, GetPSchema()->CubRecordFixed() );
+	int cubRead = GetPSchema()->CubRecordFixed();
+	return cubRead;
+}
+
+int CRecordVar::InitFromBytes( uint8 *pubRecord )
+{
+	Cleanup();
+
+	Q_memcpy( PubRecordFixed(), pubRecord, GetPSchema()->CubRecordFixed() );
+	int cubRead = GetPSchema()->CubRecordFixed();
+	if ( VarFieldBlockInfo_t *pVarBlockInfo = GetPSchema()->PVarFieldBlockInfoFromRecord(	PubRecordFixed() ) )
+	{
+		if ( pVarBlockInfo->m_cubBlock )
+		{
+			void *pvNewBlock = malloc( pVarBlockInfo->m_cubBlock );
+			Q_memcpy( pvNewBlock, pVarBlockInfo->m_pubBlock, pVarBlockInfo->m_cubBlock );
+			pVarBlockInfo->m_pubBlock = ( uint8 * )pvNewBlock;
+			SetFlag( k_EAllocatedVarBlock, true );
+			cubRead += pVarBlockInfo->m_cubBlock;
+		}
+	}
+
+	return cubRead;
+}
+
+
+int CRecordExternal::Init( CSchema *pSchema, uint8 *pubRecord, bool bTakeOwnership )
+{
+	m_pSchema = pSchema;
+	m_pubRecordFixedExternal = pubRecord;
+	SetFlag( k_EAllocatedFixed, bTakeOwnership );
+	SetFlag( k_EAllocatedVarBlock, bTakeOwnership );
+	int cubRead = m_pSchema->CubRecordFixed() + CubRecordVarBlock();
+
+	return cubRead;
+}
+
+CSchema *CRecordBase::GetPSchema()
+{
+	return GetPSchemaImpl();
+}
+
+CSchema *CRecordBase::GetPSchemaImpl()
+{
+	CSchema *pSchema = NULL;
+	int i = GetITable();
+	if ( i != -1 )
+		pSchema = &GSchemaFull().GetSchema( i );
+	return pSchema;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Render a field to a buffer
+// Input:	unColumn - field to render
+//			cchBuffer - size of render buffer
+//			pchBuffer - buffer to render into
+//-----------------------------------------------------------------------------
+void CRecordBase::RenderField( uint32 unColumn, int cchBuffer, char *pchBuffer ) const
+{
+	Q_strncpy( pchBuffer, "", cchBuffer );
+
+	uint8 *pubData;
+	uint32 cubData;
+	if ( !BGetField( unColumn, &pubData, &cubData ) )
+		return;
+
+	// Get the column info and figure out how to interpret the data
+	ConvertFieldToText( GetPRecordInfo()->GetColumnInfo( unColumn ).GetType(), pubData, cubData, pchBuffer, cchBuffer, false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Reset to base state, freeing any memory we are responsible for
+//-----------------------------------------------------------------------------
+void CRecordBase::Cleanup()
+{
+}
+
+void CRecordVar::Cleanup()
+{
+	// Must do this before freeing memory that encloses it
+	// (eg releasing the net packet)
+	if ( BFlagSet( k_EAllocatedVarBlock ) )
+	{
+		void *pvVarBlock = m_pSchema->PVarFieldBlockInfoFromRecord( PubRecordFixed() )->m_pubBlock;
+		free( pvVarBlock );
+		m_pSchema->PVarFieldBlockInfoFromRecord( PubRecordFixed() )->m_pubBlock = NULL;
+		SetFlag( k_EAllocatedVarBlock, false );
+	}
+}
+
+void CRecordExternal::Cleanup()
+{
+	// clean up the variable-length memory we might have allocated
+	if ( BFlagSet( k_EAllocatedVarBlock ) )
+	{
+		void *pvVarBlock = m_pSchema->PVarFieldBlockInfoFromRecord( PubRecordFixed() )->m_pubBlock;
+		free( pvVarBlock );
+		m_pSchema->PVarFieldBlockInfoFromRecord( PubRecordFixed() )->m_pubBlock = NULL;
+		SetFlag( k_EAllocatedVarBlock, false );
+	}
+
+	// clean up the external memory we might have allocated
+	if ( BFlagSet( k_EAllocatedFixed ) )
+		free( m_pubRecordFixedExternal );
+	SetFlag( k_EAllocatedFixed, false );
+	m_pubRecordFixedExternal = NULL;
+
+	// clean up the lowest layer, not calling CRecordVar
+	CRecordBase::Cleanup();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:	Deserializes a block of memory into this record
+// Input:	pubData -		Memory block to deserialize from
+//-----------------------------------------------------------------------------
+void CRecordExternal::DeSerialize( uint8 *pubData )
+{
+	InitFromBytes( pubData );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:	Calculates the size of this record when serialized
+// Output:	Size of serialized message
+//-----------------------------------------------------------------------------
+uint32 CRecordBase::CubSerialized()
+{
+	return CubRecordFixed() + CubRecordVarBlock();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get pointer to fixed part of record
+// Output:	pubRecordFixed
+//-----------------------------------------------------------------------------
+uint8* CRecordBase::PubRecordFixed()
+{
+	return ( uint8 * )( this + 1 );
+}
+
+uint8* CRecordExternal::PubRecordFixed()
+{
+	Assert( m_pubRecordFixedExternal );
+	return m_pubRecordFixedExternal;
+}
+
+uint8* CRecordVar::PubRecordFixed()
+{
+	return ( uint8 * )( this + 1 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get pointer to fixed part of record
+// Output:	pubRecordFixed
+//-----------------------------------------------------------------------------
+const uint8* CRecordBase::PubRecordFixed() const
+{
+	return const_cast<CRecordBase *>( this )->PubRecordFixed();
+}
+
+const uint8* CRecordVar::PubRecordFixed() const
+{
+	return const_cast<CRecordVar *>( this )->PubRecordFixed();
+}
+
+const uint8* CRecordExternal::PubRecordFixed() const
+{
+	return const_cast<CRecordExternal *>( this )->PubRecordFixed();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get size of fixed part of record
+// Output:	size in bytes of fixed part
+//-----------------------------------------------------------------------------
+uint32 CRecordBase::CubRecordFixed() const
+{
+	return GetPSchema()->CubRecordFixed();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get pointer to variable part of record
+// Output:	Pointer to variable-length block -- may be NULL if this record
+//			has no var-length fields or they are all empty
+//-----------------------------------------------------------------------------
+uint8* CRecordBase::PubRecordVarBlock()
+{
+	VarFieldBlockInfo_t *pVarFieldBlockInfo = GetPSchema()->PVarFieldBlockInfoFromRecord( PubRecordFixed() );
+	if ( pVarFieldBlockInfo )
+	{
+		return pVarFieldBlockInfo->m_pubBlock;
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get pointer to variable part of record
+// Output:	Pointer to variable-length block -- may be NULL if this record
+//			has no var-length fields or they are all empty
+//-----------------------------------------------------------------------------
+const uint8* CRecordBase::PubRecordVarBlock() const
+{
+	return const_cast<CRecordBase *>( this )->PubRecordVarBlock();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get size of variable part of record
+// Output:	Size in bytes of var-length block - may be zero if this record
+//			has no var-length fields or they are all empty
+//-----------------------------------------------------------------------------
+uint32 CRecordBase::CubRecordVarBlock()  const
+{
+	VarFieldBlockInfo_t *pVarFieldBlockInfo = GetPSchema()->PVarFieldBlockInfoFromRecord( PubRecordFixed() );
+	if ( pVarFieldBlockInfo )
+	{
+		return pVarFieldBlockInfo->m_cubBlock;
+	}
+	else
+	{
+		return 0;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get size of variable part of record
+// Output:	Size in bytes of var-length block - may be zero if this record
+//			has no var-length fields or they are all empty
+//-----------------------------------------------------------------------------
+bool CRecordBase::BAssureRecordVarStorage( uint32 cVariableBytes )
+{
+	// get the variable field block
+	VarFieldBlockInfo_t *pVarFieldBlockInfo = GetPSchema()->PVarFieldBlockInfoFromRecord( PubRecordFixed() );
+	if ( pVarFieldBlockInfo )
+	{
+		// if we have it, see if it's got enough storage
+		if ( pVarFieldBlockInfo->m_cubBlock >= cVariableBytes )
+		{
+			// already there
+			return true;
+		}
+
+		// allocate it
+		uint8* pubData = (uint8*) malloc( cVariableBytes );
+		if ( pubData == NULL )
+			return false;
+
+		// do we have something right now?
+		if ( pVarFieldBlockInfo->m_cubBlock != 0 )
+		{
+			// sure do. copy it over.
+			Q_memcpy( pubData, pVarFieldBlockInfo->m_pubBlock, pVarFieldBlockInfo->m_cubBlock );
+
+			// free what was there
+			free( pVarFieldBlockInfo->m_pubBlock );
+		}
+
+		// hook up our buffer
+		pVarFieldBlockInfo->m_cubBlockFree = cVariableBytes - pVarFieldBlockInfo->m_cubBlock;
+		pVarFieldBlockInfo->m_cubBlock = cVariableBytes;
+		pVarFieldBlockInfo->m_pubBlock = pubData;
+
+		return true;
+	}
+	else
+	{
+		// we don't have one;
+		// we've got no variable length fields, and so can't preallocate for them!
+		return false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Initialize this whole record to random data
+// Input:	unPrimaryIndex -		Primary index to set
+//-----------------------------------------------------------------------------
+void CRecordExternal::InitRecordRandom( uint32 unPrimaryIndex )
+{
+	bool bRealloced = false;
+	GetPSchema()->InitRecordRandom( PubRecordFixed(), unPrimaryIndex, &bRealloced, BFlagSet( k_EAllocatedVarBlock ) );
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Set a field in this record to random bits
+// Input:	iField -			Field to set
+//-----------------------------------------------------------------------------
+void CRecordExternal::SetFieldRandom( int iField )
+{
+	bool bRealloced = false;
+	GetPSchema()->SetFieldRandom( PubRecordFixed(), iField, &bRealloced, BFlagSet( k_EAllocatedVarBlock ) );
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a field (var or fixed) from this record
+// Input:	iField -			Field to set
+//			ppubData -			Receives pointer to fields data
+//			pcubField -			Receives count of bytes of data (will count the null for strings)
+// Output:	true if succeeds
+//-----------------------------------------------------------------------------
+bool CRecordBase::BGetField( int iField, uint8 **ppubData, uint32 *pcubField ) const
+{
+	return GetPSchema()->BGetFieldData( PubRecordFixed(), iField, ppubData, pcubField );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the data for a field, whether fixed or variable length
+// Input:	iField -			index of field to set
+//			pubData -			pointer to field data to copy from
+//			cubData -			size in bytes of that data
+// Output:	true if successful
+//-----------------------------------------------------------------------------
+bool CRecordBase::BSetField( int iField, void *pvData, uint32 cubData )
+{
+	bool bRealloced = false;
+	bool bResult = BSetField( iField, pvData, cubData, &bRealloced );
+	Assert( !bRealloced );
+
+	return bResult;
+}
+
+bool CRecordBase::BSetField( int iField, void *pvData, uint32 cubData, bool *pbRealloced )
+{
+	uint8 *pubData = reinterpret_cast<uint8 *>( pvData );
+	
+	if ( !GetPSchema()->BSetFieldData( PubRecordFixed(), iField, pubData, cubData, pbRealloced ) )
+		return false;
+
+	return true;
+}
+
+bool CRecordVar::BSetField( int iField, void *pvData, uint32 cubData )
+{
+	bool bRealloced = false;
+	bool bResult = CRecordBase::BSetField( iField, pvData, cubData, &bRealloced );
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+	return bResult;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Erases a field, setting it to 0 length (if possible) and filling with nulls
+// Input:	iField -			index of field to wipe
+// NOTE:	This relies on CSchema::BSetFieldData nulling out the rest of a field when it is set to 0 length!
+//-----------------------------------------------------------------------------
+void CRecordBase::WipeField( int iField )
+{
+	bool bRealloced = false;
+
+	// Empty Data
+	uint32 un = 0;
+
+	// Length should be 0, except for non-variable length strings where length should be 1 (for an empty string "")
+	int cub = 0;
+	Field_t &field = GetPSchema()->GetField( iField );
+	Assert( !field.BIsVariableLength() );
+	if ( field.BIsStringType() )
+		cub = 1;
+
+	GetPSchema()->BSetFieldData( PubRecordFixed(), iField, ( uint8 * ) &un, cub, &bRealloced );
+
+	Assert( !bRealloced );
+}
+
+void CRecordVar::WipeField( int iField )
+{
+	bool bRealloced = false;
+
+	// Empty Data
+	uint32 un = 0;
+
+	// Length should be 0, except for non-variable length strings where length should be 1 (for an empty string "")
+	int cub = 0;
+	Field_t &field = GetPSchema()->GetField( iField );
+	if ( field.BIsStringType() && !field.BIsVariableLength() )
+		cub = 1;
+
+	GetPSchema()->BSetFieldData( PubRecordFixed(), iField, ( uint8 * ) &un, cub, &bRealloced );
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a string field - will return empty string instead of NULL if field has no datas
+// Input:	iField -			Field to get
+//			pcubField -			Receives count of bytes of data (will count the null for strings)
+// Output:	const pointer to string data (to an empty string if no data)
+//-----------------------------------------------------------------------------
+const char * CRecordBase::GetStringField( int iField, uint32 *pcubField )
+{
+	uint8 * pubData = NULL;
+	*pcubField = 0;
+
+	if ( BGetField( iField, &pubData, pcubField ) && *pcubField > 0 )
+		return ( const char * ) pubData;
+	else
+		return "";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get an int field
+// Input:	iField -			Field to get
+// Output:	Int (0 if no data)
+//-----------------------------------------------------------------------------
+int CRecordBase::GetInt( int iField )
+{
+	return ( int ) GetUint32( iField );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a uint16 field
+// Input:	iField -			Field to get
+// Output:	uint16 (0 if no data)
+//-----------------------------------------------------------------------------
+uint16 CRecordBase::GetUint16( int iField )
+{
+	uint8 * pubData = NULL;
+	uint32 cubField = 0;
+
+	DbgVerify( BGetField( iField, &pubData, &cubField ) );
+	Assert( 0 < cubField );
+
+	if ( NULL != pubData )
+		return *( uint16 * ) pubData;
+	else
+		return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a uint32 field
+// Input:	iField -			Field to get
+// Output:	uint32 (0 if no data)
+//-----------------------------------------------------------------------------
+uint32 CRecordBase::GetUint32( int iField )
+{
+	uint8 * pubData = NULL;
+	uint32 cubField = 0;
+
+	DbgVerify( BGetField( iField, &pubData, &cubField ) );
+	Assert( 0 < cubField );
+
+	if ( NULL != pubData )
+		return *( uint32 * ) pubData;
+	else
+		return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a uint64 field
+// Input:	iField -			Field to get
+// Output:	uint64 (0 if no data)
+//-----------------------------------------------------------------------------
+uint64 CRecordBase::GetUint64( int iField )
+{
+	uint8 * pubData = NULL;
+	uint32 cubField = 0;
+
+	DbgVerify( BGetField( iField, &pubData, &cubField ) );
+	Assert( 0 < cubField );
+
+	if ( NULL != pubData )
+		return *( uint64 * ) pubData;
+	else
+		return 0;
+}
+
+
+
+const char * CRecordBase::ReadVarCharField( const CVarCharField &field ) const
+{
+	Assert( false );
+	return NULL;
+}
+
+const uint8 * CRecordBase::ReadVarDataField( const CVarField &field, uint32 *pcubField ) const
+{
+	Assert( false );
+	return NULL;
+}
+
+// These may cause a realloc
+bool CRecordBase::SetVarCharField( CVarCharField &field, const char *pchString, bool bTruncate, int32 iField )
+{
+	Assert( false );
+	return false ;
+}
+
+void CRecordBase::SetVarDataField( CVarField &field, const void *pvData, uint32 cubData )
+{
+	Assert( false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Read data from a varchar field
+// Input:	field -				opaque field object to read from
+// Output:	pointer to data - may be NULL if that field is empty.
+//-----------------------------------------------------------------------------
+const char * CRecordVar::ReadVarCharField( const CVarCharField &field ) const
+{
+	Assert ( GetPSchema()->BHasVariableFields() );
+
+	uint8 *pubData;
+	uint32 cubData;
+	if ( GetPSchema()->BGetVarField( PubRecordFixed(), &field, &pubData, &cubData ) )
+		return (const char *)pubData;
+	else
+		return "";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Read data from a vardata field
+// Input:	field -				opaque field object to read from
+// Output:	pointer to data - may be NULL if that field is empty.
+//-----------------------------------------------------------------------------
+const uint8 *CRecordVar::ReadVarDataField( const CVarField &field, uint32 *pcubField ) const
+{
+	Assert ( GetPSchema()->BHasVariableFields() );
+
+	uint8 *pubData;
+	*pcubField = 0;
+	if ( GetPSchema()->BGetVarField( PubRecordFixed(), &field, &pubData, pcubField ) )
+		return pubData;
+	else
+		return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Update (in memory) a varchar field
+// Input:	field -				opaque field object to update
+//			pchString -			string data to set
+//-----------------------------------------------------------------------------
+bool CRecordVar::SetVarCharField( CVarCharField &field, const char *pchString, bool bTruncate, int32 iField )
+{
+	Assert ( GetPSchema()->BHasVariableFields() );
+	if( iField < 0 )
+	{
+		AssertMsg1( false, "Encountered a bad call to SetVarCharField with an invalid field specified: %d", iField );
+		return false;
+	}
+
+	bool bTruncated = false;
+	int cchLen = Q_strlen( pchString ) + 1;
+	
+	// since we're a VARCHAR field, cbMaxLength is the length in characters
+	const int cchMaxLength = m_pSchema->GetField( iField ).m_cchMaxLength;
+	if ( ( cchMaxLength > 0 )  && ( cchLen > cchMaxLength ) )
+	{
+		if( bTruncate )
+		{
+			bTruncated = true;
+			cchLen = cchMaxLength;
+		}
+		else
+		{
+			// caller should check his data and not pass stuff that wont fit
+			AssertMsg4( false, "Overflow in SetVarCharField (%u > %u) for column %s in table %s", cchLen, cchMaxLength, m_pSchema->GetField( iField ).m_rgchName, m_pSchema->GetPchName() );
+			return false;
+		}
+	}
+
+	bool bRealloced = false;
+	bool fSuccess = GetPSchema()->BSetVarField( PubRecordFixed(), &field, pchString, cchLen, &bRealloced, BFlagSet( k_EAllocatedVarBlock ) );
+	if( fSuccess && bTruncated )
+	{
+		//make sure the last character is NULL if we truncated
+		VarFieldBlockInfo_t *pBlock = GetPSchema()->PVarFieldBlockInfoFromRecord( PubRecordFixed() );
+		uint8 *pubVarBlock = pBlock->m_pubBlock;
+		char* pField = ( char* )( pubVarBlock + field.m_dubOffset );
+		pField[ cchLen - 1 ] = '\0';
+	}
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+	return fSuccess;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Update (in memory) a vardata field
+// Input:	field -				opaque field object to update
+//			pvData -			pointer to data to put there
+//			cubData -			size in bytes of the data
+//-----------------------------------------------------------------------------
+void CRecordVar::SetVarDataField( CVarField &field, const void *pvData, uint32 cubData )
+{
+	Assert ( GetPSchema()->BHasVariableFields() );
+
+	bool bRealloced = false;
+	GetPSchema()->BSetVarField( PubRecordFixed(), &field, pvData, cubData, &bRealloced, BFlagSet( k_EAllocatedVarBlock ) );
+
+	if ( bRealloced )
+		SetFlag( k_EAllocatedVarBlock, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Set or clear the specified flag in m_nFlags
+// Input:	eFlag -				flag (single bit) to change
+//			bSet -				Set it, else clear it
+//-----------------------------------------------------------------------------
+void CRecordVar::SetFlag( int eFlag, bool bSet )
+{
+	if ( bSet )
+		m_nFlags |= eFlag;
+	else
+		m_nFlags &= ~eFlag;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the state of the specified flag
+// Input:	eFlag -				flag (single bit) to check
+//-----------------------------------------------------------------------------
+bool CRecordVar::BFlagSet( int eFlag ) const
+{
+	return 0 != ( m_nFlags & eFlag );
+}
+
+
+#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 CRecordBase::Validate( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE();
+}
+
+void CRecordVar::Validate( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE();
+
+	if ( BFlagSet( k_EAllocatedVarBlock ) )
+	{
+		validator.ClaimMemory( GetPSchema()->PVarFieldBlockInfoFromRecord( PubRecordFixed() )->m_pubBlock );
+	}
+
+}
+
+void CRecordExternal::Validate( CValidator &validator, const char *pchName )
+{
+	if ( BFlagSet( k_EAllocatedFixed ) )
+	{
+		validator.ClaimMemory( m_pubRecordFixedExternal );
+	}
+
+	CRecordBase::Validate( validator, pchName );
+}
+
+void CRecordBase::ValidateStatics( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE_STATIC( "CRecordBase class statics" );
+}
+
+#endif // DBGFLAG_VALIDATE
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the schema for this record type
+//-----------------------------------------------------------------------------
+CSchema *CRecordType::GetSchema() const
+{
+	return &GSchemaFull().GetSchema( GetITable() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Return the CRecordInfo for this record type
+//-----------------------------------------------------------------------------
+CRecordInfo *CRecordType::GetRecordInfo() const
+{
+	return GetSchema()->GetRecordInfo();
+}
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/recordinfo.cpp b/gcsdk/sqlaccess/recordinfo.cpp
new file mode 100644
index 0000000..57fb435
--- /dev/null
+++ b/gcsdk/sqlaccess/recordinfo.cpp
@@ -0,0 +1,915 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================
+
+
+#include "stdafx.h"
+
+//#include "sqlaccess.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+namespace GCSDK
+{
+// Memory pool for CRecordInfo
+CThreadSafeClassMemoryPool<CRecordInfo> CRecordInfo::sm_MemPoolRecordInfo( 10, UTLMEMORYPOOL_GROW_FAST );
+
+#ifdef _DEBUG
+// validation tracking
+CUtlRBTree<CRecordInfo *, int > CRecordInfo::sm_mapPMemPoolRecordInfo( DefLessFunc( CRecordInfo *) );
+CThreadMutex CRecordInfo::sm_mutexMemPoolRecordInfo;
+#endif
+
+
+//-----------------------------------------------------------------------------
+// determine if this fieldset is equal to the other one
+//-----------------------------------------------------------------------------
+/* static */
+bool FieldSet_t::CompareFieldSets( const FieldSet_t& refThis, CRecordInfo* pRecordInfoThis,
+	const FieldSet_t& refOther, CRecordInfo* pRecordInfoOther )
+{
+	// same number of columns?
+	int cColumns = refThis.GetCount();
+	if ( refOther.GetCount() != cColumns )
+		return false;
+
+	int cIncludedColumns = refThis.GetIncludedCount();
+	if ( refOther.GetIncludedCount() != cIncludedColumns )
+		return false;
+
+	// do the regular columns first; this is order-dependent
+	for ( int m = 0; m < cColumns; m++ )
+	{
+		int nThisField = refThis.GetField( m );
+		const CColumnInfo& refThisColumn = pRecordInfoThis->GetColumnInfo( nThisField );
+
+		int nOtherField = refOther.GetField( m );
+		const CColumnInfo& refOtherColumn = pRecordInfoOther->GetColumnInfo( nOtherField );
+
+		if ( refOtherColumn != refThisColumn )
+		{
+			return false;
+		}
+	}
+
+	// do the included columns now; order independent
+	for ( int m = 0; m < cIncludedColumns; m++ )
+	{
+		int nThisField = refThis.GetIncludedField( m );
+		const CColumnInfo& refThisColumn = pRecordInfoThis->GetColumnInfo( nThisField );
+		bool bFoundMatch = false;
+
+		for ( int n = 0; n < cIncludedColumns; n++ )
+		{
+			int nOtherField = refOther.GetIncludedField( n );
+			const CColumnInfo& refOtherColumn = pRecordInfoOther->GetColumnInfo( nOtherField );
+
+			if ( refOtherColumn == refThisColumn )
+			{
+				bFoundMatch = true;
+				break;
+			}
+		}
+
+		if ( !bFoundMatch )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CRecordInfo::CRecordInfo()
+: m_MapIColumnInfo( 0, 0, CaselessStringLessThan )
+{
+	m_rgchName[0] = 0;
+	m_bPreparedForUse = false;
+	m_bAllColumnsAdded = false;
+	m_bHaveChecksum = false;
+	m_bHaveColumnNameIndex = false;
+	m_nHasPrimaryKey = k_EPrimaryKeyTypeNone;
+	m_iPKIndex = -1;
+	m_cubFixedSize = 0;
+	m_nChecksum = 0;
+	m_eSchemaCatalog = k_ESchemaCatalogInvalid;
+	m_nTableID = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Initializes this record info from DS equivalent information
+//-----------------------------------------------------------------------------
+void CRecordInfo::InitFromDSSchema( CSchema *pSchema )
+{
+	// copy the name over
+	SetName( pSchema->GetPchName() );
+
+	// copy each of the fields, preallocating capacity
+	int cFields = pSchema->GetCField();
+	m_VecColumnInfo.EnsureCapacity( cFields );
+	for ( int iField = 0; iField < cFields; iField++ )
+	{
+		Field_t &field = pSchema->GetField( iField );
+		AddColumn( field.m_rgchSQLName, iField+1, field.m_EType, field.m_cubLength, field.m_nColFlags, field.m_cchMaxLength );
+	}
+
+	m_nTableID = pSchema->GetITable();
+
+	// copy the list of PK index fields
+	m_iPKIndex = pSchema->GetPKIndex( );
+
+	// copy the list of Indexes
+	m_VecIndexes = pSchema->GetIndexes( );
+
+	// which schema?
+	m_eSchemaCatalog = pSchema->GetESchemaCatalog();
+
+	// copy full-text column list
+	// and the index of the catalog it will create on
+	m_vecFTSFields = pSchema->GetFTSColumns();
+	m_nFullTextCatalogIndex = pSchema->GetFTSIndexCatalog();
+
+	// Copy over the FK data
+	int cFKs = pSchema->GetFKCount();
+	for ( int i = 0; i < cFKs; ++i )
+	{
+		FKData_t &fkData = pSchema->GetFKData( i );
+		AddFK( fkData );
+	}
+
+	// prepare for use
+	PrepareForUse( );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a new column to this record info
+// Input:	pchName - column name
+//			nSQLColumn - column index in SQL to bind to (1-based)
+//			eType - data type of column
+//			cubFixedSize - for fixed-size fields, the size
+//			nColFlags - attributes
+//-----------------------------------------------------------------------------
+void CRecordInfo::AddColumn( const char *pchName, int nSQLColumn, EGCSQLType eType, int cubFixedSize, int nColFlags, int cchMaxSize )
+{
+	Assert( !m_bPreparedForUse );
+	if ( m_bPreparedForUse )
+		return;
+	uint32 unColumn = m_VecColumnInfo.AddToTail();
+	CColumnInfo &columnInfo = m_VecColumnInfo[unColumn];
+
+	columnInfo.Set( pchName, nSQLColumn, eType, cubFixedSize, nColFlags, cchMaxSize );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a new FK to this record info
+//-----------------------------------------------------------------------------
+void CRecordInfo::AddFK( const FKData_t &fkData )
+{
+	m_VecFKData.AddToTail( fkData );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: compare function to sort by column name
+//-----------------------------------------------------------------------------
+int __cdecl CompareColumnInfo( const CColumnInfo *pColumnInfoLeft, const CColumnInfo *pColumnInfoRight )
+{
+	const char *pchLeft = ( (CColumnInfo *) pColumnInfoLeft )->GetName();
+	const char *pchRight = ( (CColumnInfo *) pColumnInfoRight )->GetName();
+	Assert( pchLeft && pchLeft[0] );	
+	Assert( pchRight && pchRight[0] );
+	return Q_stricmp( pchLeft, pchRight );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: compares this record info to another record info
+//-----------------------------------------------------------------------------
+bool CRecordInfo::EqualTo( CRecordInfo* pOther )
+{
+	int nOurs = GetChecksum();
+	int nTheirs = pOther->GetChecksum();
+
+	// if this much isn't equal, we're no good
+	if (nOurs != nTheirs)
+		return false;
+
+	if ( !CompareIndexLists( pOther ) )
+		return false;
+
+	if ( !CompareFKs( pOther ) )
+		return false;
+
+	return CompareFTSIndexLists( pOther );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: format the index list into a string
+//-----------------------------------------------------------------------------
+void CRecordInfo::GetIndexFieldList( CFmtStr1024 *pstr, int nIndents ) const
+{
+	// table name at first
+	pstr->sprintf( "Table %s:\n", this->GetName() );
+
+	// for each of the indexes ...
+	for ( int n = 0; n < m_VecIndexes.Count(); n++ )
+	{
+		const FieldSet_t& fs = m_VecIndexes[n];
+
+		// indent enough
+		for ( int x = 0; x < nIndents; x++ )
+		{
+			pstr->Append( "\t" );
+		}
+
+		// show if it is clustered or not
+		pstr->AppendFormat( "Index %d (%s): %sclustered, %sunique {", n,
+			fs.GetIndexName(),
+			fs.IsClustered() ? "" : "non-",
+			fs.IsUnique() ? "" : "non-" );
+
+		// then show all the columns
+		for (int m = 0; m < fs.GetCount(); m++ )
+		{
+			int x = fs.GetField( m );
+			const char* pstrName = m_VecColumnInfo[x].GetName();
+			pstr->AppendFormat( "%s %s", ( m == 0 ) ? "" : ",", pstrName );
+		}
+
+		// then the included columns, too
+		for ( int m = 0; m < fs.GetIncludedCount(); m++ )
+		{
+			int x = fs.GetIncludedField( m );
+			const char* pstrName = m_VecColumnInfo[x].GetName();
+			pstr->AppendFormat( ", *%s", pstrName );
+		}
+		pstr->Append( " }\n" );
+	}
+
+	return;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get the number of foreign key constraints defined for the table
+//-----------------------------------------------------------------------------
+int CRecordInfo::GetFKCount()
+{
+	return m_VecFKData.Count();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get data for a foreign key by index (valid for 0...GetFKCount()-1)
+//-----------------------------------------------------------------------------
+FKData_t &CRecordInfo::GetFKData( int iIndex )
+{
+	return m_VecFKData[iIndex];
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: format the FK list into a string
+//-----------------------------------------------------------------------------
+void CRecordInfo::GetFKListString( CFmtStr1024 *pstr, int nIndents )
+{
+	// table name at first
+	pstr->sprintf( "Table %s Foreign Keys: \n", this->GetName() );
+
+
+
+	if ( m_VecFKData.Count() == 0 )
+	{
+		// indent enough
+		pstr->AppendIndent( nIndents );
+		pstr->Append( "No foreign keys for table\n" );
+	}
+	else
+	{
+		for ( int n = 0; n < m_VecFKData.Count(); n++ )
+		{
+			// indent enough
+			pstr->AppendIndent( nIndents );
+
+			FKData_t &fkData = m_VecFKData[n];
+			CFmtStr sColumns, sParentColumns;
+			FOR_EACH_VEC( fkData.m_VecColumnRelations, i )
+			{
+				FKColumnRelation_t &colRelation = fkData.m_VecColumnRelations[i];
+				if ( i > 0)
+				{
+					sColumns += ",";
+					sParentColumns += ",";
+				}
+				sColumns += colRelation.m_rgchCol;
+				sParentColumns += colRelation.m_rgchParentCol;
+			}
+
+			pstr->AppendFormat( "CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s(%s) ON DELETE %s ON UPDATE %s\n",
+				fkData.m_rgchName, sColumns.Access(), fkData.m_rgchParentTableName, sParentColumns.Access(), 
+				PchNameFromEForeignKeyAction( fkData.m_eOnDeleteAction ), PchNameFromEForeignKeyAction( fkData.m_eOnUpdateAction ) );
+		}
+	}
+
+	return;
+}
+
+
+
+//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+void CRecordInfo::AddFTSFields( CUtlVector< int > &vecFields )
+{
+	AssertMsg( m_vecFTSFields.Count() == 0, "Only one FTS index per table" );
+	FOR_EACH_VEC( vecFields, n )
+	{
+		int nField = vecFields[n];
+		m_vecFTSFields.AddToTail( nField );
+	}
+
+	return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: compares FK lists in this record with those of another
+//-----------------------------------------------------------------------------
+bool CRecordInfo::CompareFKs( CRecordInfo *pOther )
+{
+	if ( pOther->m_VecFKData.Count() != m_VecFKData.Count() )
+		return false;
+
+	for( int i=0; i < m_VecFKData.Count(); ++i )
+	{
+		FKData_t &fkDataMine = m_VecFKData[i];
+
+		bool bFoundInOther = false;
+		for ( int j=0; j < pOther->m_VecFKData.Count(); ++j )
+		{
+			FKData_t &fkDataOther = pOther->m_VecFKData[j];
+
+			if ( fkDataMine == fkDataOther )
+			{
+				bFoundInOther = true;
+				break;
+			}
+		}
+
+		if ( !bFoundInOther )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Locate an index by its properties (ignoring the name).
+//          Returns position of index in the index array, or -1 if not found.
+//-----------------------------------------------------------------------------
+int CRecordInfo::FindIndex( CRecordInfo *pRec, const FieldSet_t& fieldSet )
+{
+	for ( int i = 0; i < m_VecIndexes.Count(); i++ )
+	{
+		if ( FieldSet_t::CompareFieldSets( m_VecIndexes[i], this, fieldSet, pRec ) )
+			return i;
+	}
+
+	// Not found
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Locate an index with the given name.
+//          Returns position of index in the index array, or -1 if not found.
+//-----------------------------------------------------------------------------
+int CRecordInfo::FindIndexByName( const char *pszName ) const
+{
+	for ( int i = 0; i < m_VecIndexes.Count(); i++ )
+	{
+		if ( V_stricmp( m_VecIndexes[i].GetIndexName(), pszName )== 0 )
+			return i;
+	}
+
+	// Not found
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: compares index lists in this record with those of another
+//-----------------------------------------------------------------------------
+bool CRecordInfo::CompareIndexLists( CRecordInfo* pOther )
+{
+	// compare the index lists (but don't use CRCs)
+
+	// different size? can't be the same
+	if ( pOther->GetIndexFieldCount() != GetIndexFieldCount() )
+	{
+		return false;
+	}
+
+	// We have to loop through both lists of indexes and try to find a match.
+	// We also must make sure the match is exact, and that no previous match
+	// can alias another attempt at a match. Pretty messy, but with no available
+	// identity over index objects, we're forced to a suboptimal solution.
+
+	int nIndexes = GetIndexFieldCount();
+
+	// get a copy of the other index vector, which we'll remove items from as
+	// matches are found.
+
+	CUtlVector<FieldSet_t> vecOtherIndexes;
+	vecOtherIndexes.CopyArray( pOther->GetIndexFields().Base(), nIndexes );
+
+	for ( int nOurs = 0; nOurs < nIndexes; nOurs++ )
+	{
+		int nOtherMatchIndex = -1;
+		const FieldSet_t& refOurs = GetIndexFields()[nOurs];
+
+		// rip through copy of other to find one that matches
+		for ( int nOther = 0; nOther < vecOtherIndexes.Count(); nOther++ )
+		{
+			const FieldSet_t& refOther = vecOtherIndexes[nOther];
+			if ( FieldSet_t::CompareFieldSets( refOurs, this, refOther, pOther ) )
+			{
+				nOtherMatchIndex = nOther;
+				break;
+			}
+		}
+
+		if ( nOtherMatchIndex >= 0 )
+		{
+			// this works! remove it from other copy
+			vecOtherIndexes.Remove( nOtherMatchIndex );
+		}
+		else
+		{
+			// something didn't match, so bail out early
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: compares full-text indexes for this record with those of another
+//			column order in an FTS is irrelevant, so this is a simple match
+//-----------------------------------------------------------------------------
+bool CRecordInfo::CompareFTSIndexLists( CRecordInfo* pOther ) const
+{
+	// compare full-text index columns
+	if ( m_vecFTSFields.Count() != pOther->m_vecFTSFields.Count() )
+	{
+		// counts don't match, so obviously no good
+		return false;
+	}
+	for ( int nColumnIndex = 0; nColumnIndex < m_vecFTSFields.Count(); nColumnIndex++ )
+	{
+		bool bFound = false;
+		for ( int nInnerIndex = 0; nInnerIndex < pOther->m_vecFTSFields.Count(); nInnerIndex++ )
+		{
+			if ( m_vecFTSFields[nInnerIndex] == pOther->m_vecFTSFields[nColumnIndex] )
+			{
+				bFound = true;
+				break;
+			}
+		}
+
+		if ( !bFound )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the checksum for this record info
+//-----------------------------------------------------------------------------
+int	CRecordInfo::GetChecksum()
+{
+	Assert( m_bPreparedForUse );
+
+	// calculate it now if we haven't already
+	if ( !m_bHaveChecksum )
+		CalculateChecksum();
+
+	return m_nChecksum;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Prepares this object for use after all columns have been added
+//-----------------------------------------------------------------------------
+void CRecordInfo::PrepareForUse()
+{
+	Assert( !m_bPreparedForUse );
+	Assert( 0 == m_cubFixedSize );
+	Assert( 0 == m_nChecksum );
+
+	SetAllColumnsAdded();
+
+	FOR_EACH_VEC( m_VecColumnInfo, nColumn )
+	{
+		CColumnInfo &columnInfo = m_VecColumnInfo[nColumn];
+
+		// keep track of total fixed size of all columns
+		if ( !columnInfo.BIsVariableLength() )
+			m_cubFixedSize += columnInfo.GetFixedSize();
+
+		if ( columnInfo.BIsPrimaryKey() )
+		{
+			// a PK column! if we have seen one before,
+			// know we have a-column PK; otherwise, a single column PK
+			if (m_nHasPrimaryKey == k_EPrimaryKeyTypeNone)
+				m_nHasPrimaryKey = k_EPrimaryKeyTypeSingle;
+			else
+				m_nHasPrimaryKey = k_EPrimaryKeyTypeMulti;
+		}
+	}
+
+	// make sure count matches the enum
+	/*
+	Assert( ( m_nHasPrimaryKey == k_EPrimaryKeyTypeNone && m_VecPKFields.Count() == 0 ) ||
+	( m_nHasPrimaryKey == k_EPrimaryKeyTypeMulti && m_VecPKFields.Count() > 1) ||
+	( m_nHasPrimaryKey == k_EPrimaryKeyTypeSingle && m_VecPKFields.Count() == 1) );
+	*/
+
+	m_bPreparedForUse = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns index of column with specified name
+// Input:	pchName - column name
+//			punColumn - pointer to fill in with index
+// Output:	return true if found, false otherwise
+//-----------------------------------------------------------------------------
+bool CRecordInfo::BFindColumnByName( const char *pchName, int *punColumn )
+{
+	Assert( m_bAllColumnsAdded );
+	Assert( pchName && *pchName );
+	Assert( punColumn );
+
+	*punColumn = -1;
+
+	// if we haven't already built the name index, build it now
+	if ( !m_bHaveColumnNameIndex )
+		BuildColumnNameIndex();
+
+	*punColumn = m_MapIColumnInfo.Find( pchName );
+	return ( m_MapIColumnInfo.InvalidIndex() != *punColumn );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the name of this record info
+// Input:	pchName - name
+// Notes:	record info that describes a table will have a name (the table name);
+//			record info that describes a result set will not
+//-----------------------------------------------------------------------------
+void CRecordInfo::SetName( const char *pchName )
+{
+	Assert( pchName && *pchName );
+	Assert( !m_bPreparedForUse );	// don't change this after prepared for use
+	Q_strncpy( m_rgchName, pchName, Q_ARRAYSIZE( m_rgchName ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds the column name index for fast lookup by name
+//-----------------------------------------------------------------------------
+void CRecordInfo::BuildColumnNameIndex()
+{
+	AUTO_LOCK( m_Mutex );
+
+	if ( m_bHaveColumnNameIndex )
+		return;
+
+	Assert( m_bAllColumnsAdded );
+
+	Assert( 0 == m_MapIColumnInfo.Count() );
+
+	FOR_EACH_VEC( m_VecColumnInfo, nColumn )
+	{
+		// build name->column index map
+		CColumnInfo &columnInfo = m_VecColumnInfo[nColumn];
+		m_MapIColumnInfo.Insert( columnInfo.GetName(), nColumn );
+	}
+	m_bHaveColumnNameIndex = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculates the checksum for this record info
+//-----------------------------------------------------------------------------
+void CRecordInfo::CalculateChecksum()
+{
+	AUTO_LOCK( m_Mutex );
+
+	if ( m_bHaveChecksum )
+		return;
+
+	// build the column name index if necessary
+	if ( !m_bHaveColumnNameIndex )
+		BuildColumnNameIndex();
+
+	CRC32_t crc32;
+	CRC32_Init( &crc32 );
+
+	FOR_EACH_MAP( m_MapIColumnInfo, iMapItem )
+	{
+		uint32 unColumn = m_MapIColumnInfo[iMapItem];
+		CColumnInfo &columnInfo = m_VecColumnInfo[unColumn];
+		// calculate checksum of all of our columns
+		columnInfo.CalculateChecksum();
+		int nChecksum = columnInfo.GetChecksum();
+		CRC32_ProcessBuffer( &crc32, (void*) &nChecksum, sizeof( nChecksum ) );	
+	}
+
+	// keep checksum for entire record info
+	CRC32_Final( &crc32 );
+	m_nChecksum = crc32;
+	m_bHaveChecksum = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: add another index disallowing duplicates. If a duplicate item is
+//			found, we'll set the flags on the new item from the existing one.
+//-----------------------------------------------------------------------------
+int CRecordInfo::AddIndex( const FieldSet_t& fieldSet )
+{
+	for ( int n = 0; n < m_VecIndexes.Count(); n++ )
+	{
+		FieldSet_t& fs = m_VecIndexes[n];
+		if ( FieldSet_t::CompareFieldSets( fieldSet, this, fs, this ) )
+		{
+			fs.SetClustered( fs.IsClustered() );
+			return -1;
+		}
+	}
+
+	int nRet = m_VecIndexes.AddToTail( fieldSet );
+	return nRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns true if there is an IDENTITY column in the record info
+//-----------------------------------------------------------------------------
+bool CRecordInfo::BHasIdentity() const
+{
+	FOR_EACH_VEC( m_VecColumnInfo, nColumn)
+	{
+		if( m_VecColumnInfo[nColumn].BIsAutoIncrement() )
+			return true;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CColumnInfo::CColumnInfo() 
+{
+	m_rgchName[0] = 0;
+	m_nSQLColumn = 0;
+	m_eType = k_EGCSQLTypeInvalid;
+	m_nColFlags = 0;
+	m_cubFixedSize = 0;
+	m_cchMaxSize = 0;
+	m_nChecksum = 0;
+	m_bHaveChecksum = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets column info for this column
+// Input:	pchName - column name
+//			nSQLColumn - column index in SQL to bind to (1-based)
+//			eType - data type of column
+//			cubFixedSize - for fixed-size fields, the size
+//			nColFlags - attributes
+//-----------------------------------------------------------------------------
+void CColumnInfo::Set( const char *pchName, int nSQLColumn, EGCSQLType eType, int cubFixedSize, int nColFlags, int cchMaxSize )
+{
+	Assert( !m_rgchName[0] );
+	Q_strncpy( m_rgchName, pchName, Q_ARRAYSIZE( m_rgchName ) );
+	m_nSQLColumn = nSQLColumn;
+	m_eType = eType;
+
+	m_nColFlags = nColFlags;
+	ValidateColFlags();
+
+	if ( !BIsVariableLength() )
+	{
+		Assert( cubFixedSize > 0 );
+		m_cubFixedSize = cubFixedSize;
+		m_cchMaxSize = 0;
+	}
+	else
+	{
+		// it's variable length, so we need a max length
+		m_cchMaxSize = cchMaxSize;
+		m_cubFixedSize = 0;
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns whether this column is variable length
+//-----------------------------------------------------------------------------
+bool CColumnInfo::BIsVariableLength() const
+{
+	return m_eType == k_EGCSQLType_Blob || m_eType == k_EGCSQLType_String || m_eType == k_EGCSQLType_Image;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: convert column flags to a visible representation
+//-----------------------------------------------------------------------------
+void CColumnInfo::GetColFlagDescription( char* pstrOut, int cubOutLength ) const
+{
+	if ( m_nColFlags == 0 )
+		Q_strncpy( pstrOut, "(none)", cubOutLength );
+	else
+	{
+		pstrOut[0] = 0;
+		if ( m_nColFlags & k_nColFlagIndexed )
+			Q_strncat( pstrOut, "(Indexed)", cubOutLength );
+		if ( m_nColFlags & k_nColFlagUnique )
+			Q_strncat( pstrOut, "(Unique)", cubOutLength );
+		if ( m_nColFlags & k_nColFlagPrimaryKey )
+			Q_strncat( pstrOut, "(PrimaryKey)", cubOutLength );
+		if ( m_nColFlags & k_nColFlagAutoIncrement )
+			Q_strncat( pstrOut, "(AutoIncrement)", cubOutLength );
+		if ( m_nColFlags & k_nColFlagClustered )
+			Q_strncat( pstrOut, "(Clustered)", cubOutLength );
+	}
+
+	return;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: sets column flag bits
+// Input:	nColFlag - bits to set.  (Other bits are not cleared.)
+//-----------------------------------------------------------------------------
+void CColumnInfo::SetColFlagBits( int nColFlag )
+{
+	ValidateColFlags();
+	m_nColFlags |= nColFlag;	// set these bits
+	ValidateColFlags();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Calculates the checksum for this column
+//-----------------------------------------------------------------------------
+void CColumnInfo::CalculateChecksum()
+{
+	if ( m_bHaveChecksum )
+		return;
+
+	// calculate checksum of this column for easy comparsion
+	CRC32_t crc32;
+	CRC32_Init( &crc32 );
+	CRC32_ProcessBuffer( &crc32, (void*) m_rgchName, Q_strlen( m_rgchName ) );
+	CRC32_ProcessBuffer( &crc32, (void*) &m_nColFlags, sizeof( m_nColFlags ) );
+	CRC32_ProcessBuffer( &crc32, (void*) &m_eType, sizeof( m_eType ) );
+	CRC32_ProcessBuffer( &crc32, (void*) &m_cubFixedSize, sizeof( m_cubFixedSize ) );
+	CRC32_ProcessBuffer( &crc32, (void*) &m_cchMaxSize, sizeof( m_cchMaxSize ) );
+	CRC32_Final( &crc32 );
+
+	m_nChecksum = crc32;
+	m_bHaveChecksum = true;
+}
+
+//-----------------------------------------------------------------------------
+// determine if this CColumnInfo is the same as the referenced
+//-----------------------------------------------------------------------------
+bool CColumnInfo::operator==( const CColumnInfo& refOther ) const
+{
+	if ( m_eType != refOther.m_eType )
+		return false;
+	if ( m_cubFixedSize != refOther.m_cubFixedSize )
+		return false;
+	if ( m_cchMaxSize != refOther.m_cchMaxSize )
+		return false;
+	if ( m_nColFlags != refOther.m_nColFlags )
+		return false;
+	if ( 0 != Q_strcmp( m_rgchName, refOther.m_rgchName ) )
+		return false;
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Validates that column flags are set in valid combinations
+//-----------------------------------------------------------------------------
+void CColumnInfo::ValidateColFlags() const
+{
+	// Check that column flags follow rules about how columns get expressed in SQL
+
+	if ( m_nColFlags & k_nColFlagPrimaryKey )
+	{
+		// a primary key must also be unique and indexed
+		Assert( m_nColFlags & k_nColFlagUnique );
+		Assert( m_nColFlags & k_nColFlagIndexed );
+	}
+
+	// a column with uniqueness constraint must also be indexed
+	if ( m_nColFlags & k_nColFlagUnique )
+		Assert( m_nColFlags & k_nColFlagIndexed );
+}
+
+
+CRecordInfo *CRecordInfo::Alloc() 
+{ 
+	CRecordInfo *pRecordInfo = sm_MemPoolRecordInfo.Alloc();
+
+#ifdef _DEBUG
+	AUTO_LOCK( sm_mutexMemPoolRecordInfo );
+	sm_mapPMemPoolRecordInfo.Insert( pRecordInfo );
+#endif
+
+	return pRecordInfo;
+}
+
+
+void CRecordInfo::DestroyThis() 
+{ 
+#ifdef _DEBUG
+	AUTO_LOCK( sm_mutexMemPoolRecordInfo );
+	sm_mapPMemPoolRecordInfo.Remove( this );
+#endif
+
+	sm_MemPoolRecordInfo.Free( this ); 
+}
+
+
+#ifdef DBGFLAG_VALIDATE
+
+
+void CRecordInfo::ValidateStatics( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE_STATIC( "CRecordInfo class statics" );
+
+	ValidateObj( sm_MemPoolRecordInfo );
+
+#ifdef _DEBUG
+	AUTO_LOCK( sm_mutexMemPoolRecordInfo );
+	ValidateObj( sm_mapPMemPoolRecordInfo );
+	FOR_EACH_MAP_FAST( sm_mapPMemPoolRecordInfo, i )
+	{
+		sm_mapPMemPoolRecordInfo[i]->Validate( validator, "sm_mapPMemPoolRecordInfo[i]" );
+	}
+#endif
+}
+
+
+void CRecordInfo::Validate( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE();
+
+	m_VecIndexes.Validate( validator, "m_VecIndexes" );
+
+	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_vecFTSFields );
+
+	ValidateObj( m_VecColumnInfo );
+	FOR_EACH_VEC( m_VecColumnInfo, nColumn )
+	{
+		CColumnInfo &columnInfo = GetColumnInfo( nColumn );
+		ValidateObj( columnInfo );
+	}
+	ValidateObj( m_MapIColumnInfo );
+}
+
+void CColumnInfo::Validate( CValidator &validator, const char *pchName )
+{
+	VALIDATE_SCOPE();
+
+}
+
+#endif // DBGFLAG_VALIDATE
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/schema.cpp b/gcsdk/sqlaccess/schema.cpp
new file mode 100644
index 0000000..e92be8e
--- /dev/null
+++ b/gcsdk/sqlaccess/schema.cpp
@@ -0,0 +1,1505 @@
+//========= 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
diff --git a/gcsdk/sqlaccess/schemafull.cpp b/gcsdk/sqlaccess/schemafull.cpp
new file mode 100644
index 0000000..d8e9490
--- /dev/null
+++ b/gcsdk/sqlaccess/schemafull.cpp
@@ -0,0 +1,409 @@
+//========= 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
diff --git a/gcsdk/sqlaccess/schemaupdate.cpp b/gcsdk/sqlaccess/schemaupdate.cpp
new file mode 100644
index 0000000..b15b5f0
--- /dev/null
+++ b/gcsdk/sqlaccess/schemaupdate.cpp
@@ -0,0 +1,1696 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Contains the job that's responsible for updating the database schema
+//
+//=============================================================================
+
+#include "stdafx.h"
+#include "gcsdk/sqlaccess/schemaupdate.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+namespace GCSDK
+{
+#ifndef SQL_SUCCESS
+#define SQL_SUCCESS                0
+#define SQL_SUCCESS_WITH_INFO      1
+#define SQL_NO_DATA              100
+#define SQL_ERROR                 (-1)
+#endif // SQLSUCCESS
+
+// this comes from sql.h. The GC really shouldn't depend on the MSSQL headers
+#define SQL_INDEX_CLUSTERED 1
+
+inline bool SQL_OK( SQLRETURN nRet )
+{
+	return ( ( SQL_SUCCESS == nRet ) || (SQL_SUCCESS_WITH_INFO == nRet ) );
+}
+
+#define SQL_FAILED( ret )	( !SQL_OK( ret ) )
+
+#define EXIT_ON_SQL_FAILURE( ret ) \
+{ \
+	if ( !SQL_OK( ret ) ) \
+{ \
+	goto Exit;	\
+}  \
+}
+
+#define EXIT_ON_BOOLSQL_FAILURE( ret ) \
+{ \
+	if ( !(ret) ) \
+{ \
+	nRet = SQL_ERROR; \
+	goto Exit;	\
+}  \
+}
+
+#define RETURN_SQL_ERROR_ON_FALSE( ret ) \
+	if( !(ret) ) \
+	{\
+		return SQL_ERROR;\
+	}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Emits a message and appends it to a string
+//-----------------------------------------------------------------------------
+void EmitAndAppend( CFmtStr1024 & sTarget, const CGCEmitGroup& Group, int iLevel, int iLevelLog, PRINTF_FORMAT_STRING const char *pchMessage, ... )
+{
+	va_list args;
+	va_start( args, pchMessage );
+
+	if( sTarget.Length() < 1024 )
+		sTarget.AppendFormatV( pchMessage, args );
+
+	EmitInfoV( Group, iLevel, iLevelLog, pchMessage, args );
+
+	va_end( args );
+}
+
+//-----------------------------------------------------------------------------
+// builds a command of the form:
+//		CREATE [CLUSTERED] [UNIQUE] INDEX <index_name> ON <table_name>
+//		(col1, col2, ...)
+//		[INCLUDE (icol1, icol2, ...)]
+//		[WITH (FILLFACTOR = n)]
+//-----------------------------------------------------------------------------
+CUtlString GetAddIndexSQL( CRecordInfo *pRecordInfo, const FieldSet_t &refFields )
+{
+	CFmtStrMax sCmd;
+	sCmd.sprintf( "CREATE %s%sINDEX %s ON App%u.%s (",
+		refFields.IsClustered() ? "CLUSTERED " : "",
+		refFields.IsUnique() ? "UNIQUE " : "",
+		refFields.GetIndexName(),
+		GGCBase()->GetAppID(),
+		pRecordInfo->GetName() );
+
+	// add real columns
+	for ( int n = 0; n < refFields.GetCount(); n++ )
+	{
+		int nField = refFields.GetField( n );
+		const CColumnInfo &refInfo = pRecordInfo->GetColumnInfo( nField );
+
+		sCmd.AppendFormat( "%s%s", 
+			(n > 0) ? "," : "",
+			refInfo.GetName() );
+	}
+	sCmd += ")";
+
+	// do we have any included columns?
+	if ( refFields.GetIncludedCount() > 0 )
+	{
+		// yes, add those
+		sCmd += "\nINCLUDE (";
+
+		for ( int n = 0; n < refFields.GetIncludedCount(); n++ )
+		{
+			int nField = refFields.GetIncludedField( n );
+			const CColumnInfo &refInfo = pRecordInfo->GetColumnInfo( nField );
+
+			sCmd.AppendFormat( "%s%s", 
+				(n > 0) ? "," : "",
+				refInfo.GetName() );
+		}
+		sCmd += ")";
+	}
+
+	// do we need a fill factor?
+	if ( refFields.GetFillFactor() != 0)
+	{
+		sCmd.AppendFormat("\nWITH (FILLFACTOR = %d)",
+			refFields.GetFillFactor() );
+	}
+
+	return CUtlString( sCmd.String() );
+}
+
+CUtlString GetAlterColumnText( CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfoDesired )
+{
+	Assert( pRecordInfo );
+	Assert( pColumnInfoDesired );
+
+	char rgchTmp[128];
+	CUtlString sCmd;
+	sCmd.Format( "ALTER TABLE App%u.%s ALTER COLUMN %s %s %s", GGCBase()->GetAppID(), pRecordInfo->GetName(), pColumnInfoDesired->GetName(),
+		SQLTypeFromField( *pColumnInfoDesired, rgchTmp, Q_ARRAYSIZE( rgchTmp ) ),
+		pColumnInfoDesired->BIsPrimaryKey() ? "NOT NULL" : ""
+	);
+	return sCmd;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CSchemaUpdate::CSchemaUpdate()
+{
+	m_mapPRecordInfoDesired.SetLessFunc( CaselessStringLessThan );
+	m_eConversionMode = k_EConversionModeInspectOnly;
+
+	m_bConversionNeeded = false;
+	m_cTablesDesiredMissing = 0;
+	m_cTablesActualDifferent = 0;
+	m_cTablesActualUnknown = 0;
+	m_cTablesNeedingChange = 0;
+	m_cColumnsDesiredMissing = 0;
+	m_cColumnsActualDifferent = 0;
+	m_cColumnsActualUnknown = 0;
+	m_bSkippedAChange = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CSchemaUpdate::~CSchemaUpdate()
+{
+	// release all the record info's we're holding onto
+	FOR_EACH_MAP_FAST( m_mapPRecordInfoDesired, iRecordInfo )
+	{
+		SAFE_RELEASE( m_mapPRecordInfoDesired[iRecordInfo] );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a record info that describes a desired table that should
+//			exist in the database
+// Input:	pRecordInfo - pointer to record info
+//-----------------------------------------------------------------------------
+void CSchemaUpdate::AddRecordInfoDesired( CRecordInfo *pRecordInfo )
+{
+	Assert( pRecordInfo );
+	const char *pchName = pRecordInfo->GetName();
+	Assert( pchName && pchName[0] );
+	Assert( m_mapPRecordInfoDesired.InvalidIndex() == m_mapPRecordInfoDesired.Find( pchName ) );
+	// addref the record info since we're hanging onto it
+	pRecordInfo->AddRef();
+	// insert it in our map, indexed by name
+	m_mapPRecordInfoDesired.Insert( pchName, pRecordInfo );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a CFTSCatalogInfo that tells us about a FTS catalog that
+//			should exist in the database
+//-----------------------------------------------------------------------------
+void CSchemaUpdate::AddFTSInfo( const CFTSCatalogInfo &refFTSInfo )
+{
+	m_listFTSCatalogInfo.AddToTail( refFTSInfo );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a CFTSCatalogInfo that tells us about a FTS catalog that
+//			should exist in the database
+//-----------------------------------------------------------------------------
+void CSchemaUpdate::AddTriggerInfos( const CUtlVector< CTriggerInfo > &refTriggerInfo )
+{
+	m_vecTriggerInfo = refTriggerInfo;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Validates and updates the database schema
+//-----------------------------------------------------------------------------
+bool CJobUpdateSchema::BYieldingRunJob( void * )
+{
+	// update the main schema
+	EmitInfo( SPEW_GC, 2, 2, "Updating main schema...\n" );
+	if ( !BYieldingUpdateSchema( k_ESchemaCatalogMain ) )
+	{
+		m_pGC->SetStartupComplete( false );
+		return false;
+	}
+
+	// Could fail, but we shouldn't stop from starting up if it does
+	BYieldingUpdateSchema( k_ESchemaCatalogOGS );
+
+	bool bSuccess = m_pGC->BYieldingFinishStartup();
+	m_pGC->SetStartupComplete( bSuccess );
+	if ( bSuccess )
+	{
+		bSuccess = m_pGC->BYieldingPostStartup();
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CJobUpdateSchema::BYieldingUpdateSchema( ESchemaCatalog eSchemaCatalog )
+{
+	if( !YieldingBuildTypeMap( eSchemaCatalog ) )
+		return false;
+
+	// make an object to communicate desired database schema & results
+	CSchemaUpdate *pSchemaUpdate = new CSchemaUpdate();
+
+	// do safe conversions only
+	// TODO - do one round of inspection only first so we can send watchdog alert about what's about
+	// to happen, then do conversions.  Also force conversions in dev system.
+	pSchemaUpdate->m_eConversionMode = k_EConversionModeConvertSafe;
+
+	// Add all the tables to desired schema
+	for ( int iTable = 0; iTable < m_iTableCount; iTable++ )
+	{
+		// MERGE COMMENT: "schema" cannot be used as a variable name because it is an empty #define resulting in error C2059
+		CSchema &gc_schema = GSchemaFull().GetSchema( iTable );
+
+		// is it in the schema we want?
+		if ( gc_schema.GetESchemaCatalog() == eSchemaCatalog )
+			pSchemaUpdate->AddRecordInfoDesired( gc_schema.GetRecordInfo() );
+	}
+
+	// add all the FTS catalogs to the desired schema
+	for ( int n = 0; n < GSchemaFull().GetCFTSCatalogs(); n++ )
+	{
+		const CFTSCatalogInfo &refInfo = GSchemaFull().GetFTSCatalogInfo( n );
+		pSchemaUpdate->AddFTSInfo( refInfo );
+	}
+
+	pSchemaUpdate->AddTriggerInfos( GSchemaFull().GetTriggerInfos() );
+
+	SQLRETURN nRet = YieldingEnsureDatabaseSchemaCorrect( eSchemaCatalog, pSchemaUpdate );
+	if( !SQL_OK( nRet ) )
+	{
+		AssertMsg( false, "SQL Schema Update failed" );
+		return false;
+	}
+
+	SAFE_RELEASE( pSchemaUpdate );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Examines actual running schema of database, compares to specified desired
+//			schema, and changes the actual schema to correspond to desired schema
+// Input:	pSQLThread - SQL thread to execute on
+//			pSchemaUpdate - pointer to object with desired schema 
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingEnsureDatabaseSchemaCorrect( ESchemaCatalog eSchemaCatalog, CSchemaUpdate *pSchemaUpdate )
+{
+	Assert( pSchemaUpdate );
+
+	CMapPRecordInfo &mapPRecordInfoDesired = pSchemaUpdate->m_mapPRecordInfoDesired;
+	const CUtlVector< CTriggerInfo > &vecTriggerInfoDesired = pSchemaUpdate->m_vecTriggerInfo;
+	m_eConversionMode = pSchemaUpdate->m_eConversionMode;
+
+	bool bDoConversion = true;
+//	bool bDoConversion = ( ( k_EConversionModeConvertSafe == eConversionMode ) || 
+//		( k_EConversionModeConvertIrreversible == eConversionMode ) );	
+
+	CMapPRecordInfo mapPRecordInfoActual;
+	mapPRecordInfoActual.SetLessFunc( CaselessStringLessThan );
+	CUtlVector<CRecordInfo *> vecPRecordInfoDesiredMissing;
+	CUtlVector<CRecordInfo *> vecPRecordInfoActualDifferent;
+	CUtlVector<CRecordInfo *> vecPRecordInfoActualUnknown;
+	CUtlVector< CTriggerInfo > vecTriggerInfoActual;
+	CUtlVector< CTriggerInfo > vecTriggerInfoMissing;
+	CUtlVector< CTriggerInfo > vecTriggerInfoDifferent;
+
+	pSchemaUpdate->m_cTablesDesiredMissing = 0;
+	pSchemaUpdate->m_cTablesActualDifferent = 0;
+	pSchemaUpdate->m_cTablesActualUnknown = 0;
+	pSchemaUpdate->m_cTablesNeedingChange = 0;
+	pSchemaUpdate->m_cColumnsDesiredMissing = 0;
+	pSchemaUpdate->m_cColumnsActualDifferent = 0;
+	pSchemaUpdate->m_cColumnsActualUnknown = 0;
+	pSchemaUpdate->m_sDetail.Clear();
+
+	CFmtStr1024 &sDetail = pSchemaUpdate->m_sDetail;
+
+	CFastTimer tickCounterOverall;
+	tickCounterOverall.Start();
+
+	//
+	// Do some up-front bookkeeping to see how many tables need to be created and/or altered
+	//
+
+	int nSchemaID;
+	SQLRETURN nRet = YieldingGetSchemaID( eSchemaCatalog, &nSchemaID );
+	EXIT_ON_SQL_FAILURE( nRet );
+
+	// Determine the actual running schema
+	nRet = YieldingGetRecordInfoForAllTables( eSchemaCatalog, nSchemaID, mapPRecordInfoActual );
+	EXIT_ON_SQL_FAILURE( nRet );
+
+	nRet = YieldingGetTriggers( eSchemaCatalog, nSchemaID, vecTriggerInfoActual );
+	EXIT_ON_SQL_FAILURE( nRet );
+
+	// Look through the list of desired tables, find any that are missing or different from the actual schema
+	FOR_EACH_MAP_FAST( mapPRecordInfoDesired, iRecordInfoDesired )
+	{
+		// is this desired table in the currently connected catalog?
+		CRecordInfo *pRecordInfoDesired = mapPRecordInfoDesired[iRecordInfoDesired];
+		if ( pRecordInfoDesired->GetESchemaCatalog() == eSchemaCatalog )
+		{
+			// yes. do something about it
+			int iRecordInfoActual = mapPRecordInfoActual.Find( pRecordInfoDesired->GetName() );
+			if ( mapPRecordInfoDesired.InvalidIndex() == iRecordInfoActual )
+			{
+				// This table is desired but does not exist
+				vecPRecordInfoDesiredMissing.AddToTail( pRecordInfoDesired );
+			}
+			else
+			{
+				// Table with same name exists in desired & actual schemas; is it exactly the same?
+				CRecordInfo *pRecordInfoActual = mapPRecordInfoActual[iRecordInfoActual];
+				if ( !pRecordInfoDesired->EqualTo( pRecordInfoActual ) )
+				{
+					// This desired table exists but the actual table is different than desired
+					vecPRecordInfoActualDifferent.AddToTail( pRecordInfoActual );
+				}
+			}
+		}
+	}
+
+	// Now, look through the list of actual tables and find any that do not exist in the list of desired tables
+	FOR_EACH_MAP_FAST( mapPRecordInfoActual, iRecordInfoActual )
+	{
+		CRecordInfo *pRecordInfoActual = mapPRecordInfoActual[iRecordInfoActual];
+		int iRecordInfoDesired = mapPRecordInfoDesired.Find( pRecordInfoActual->GetName() );
+		if ( !mapPRecordInfoDesired.IsValidIndex( iRecordInfoDesired ) )
+		{
+			// This table exists but is not in the list of desired tables
+			// maybe it's an old table.
+
+			vecPRecordInfoActualUnknown.AddToTail( pRecordInfoActual );
+		}
+	}
+
+	// find a list of missing triggers
+	FOR_EACH_VEC( vecTriggerInfoDesired, iDesired )
+	{
+		// not of this catalog? skip it
+		if ( vecTriggerInfoDesired[ iDesired ].m_eSchemaCatalog != eSchemaCatalog )
+			continue;
+
+		// it is our catalog, so try and match
+		bool bMatched = false;
+		FOR_EACH_VEC( vecTriggerInfoActual, iActual )
+		{
+			// is it the same table and trigger name?
+			if ( vecTriggerInfoActual[ iActual ] == vecTriggerInfoDesired[ iDesired ] )
+			{
+				// yes! test the text for differences
+				if ( vecTriggerInfoActual[ iActual ].IsDifferent( vecTriggerInfoDesired[ iDesired ] ) )
+				{
+					vecTriggerInfoDifferent.AddToTail( vecTriggerInfoDesired[ iDesired ] );
+				}
+				else
+				{
+					// we have a match!
+					vecTriggerInfoActual[ iActual ].m_bMatched = true;
+					bMatched = true;
+				}
+				break;
+			}
+		}
+
+		if ( !bMatched )
+		{
+			vecTriggerInfoMissing.AddToTail( vecTriggerInfoDesired[ iDesired ] );
+		}
+	}
+
+	//
+	// Now do the actual conversion
+	//
+	EmitAndAppend( sDetail, SPEW_GC, 2, 2, "Database conversion: %s\n",
+		bDoConversion ? "beginning" : "inspection only" );
+
+
+	// find tables which need to be created
+	EmitAndAppend( sDetail, SPEW_GC, 2, 2, "# of specified tables that do not currently exist in database: %d\n", 
+		vecPRecordInfoDesiredMissing.Count() );
+	if ( vecPRecordInfoDesiredMissing.Count() > 0 )
+		pSchemaUpdate->m_bConversionNeeded = true;
+
+	// Create any tables which need to be created
+	for ( int iTable = 0; iTable < vecPRecordInfoDesiredMissing.Count(); iTable++ )
+	{
+		CRecordInfo *pRecordInfoDesired = vecPRecordInfoDesiredMissing[iTable];
+		if ( bDoConversion )
+		{
+			CFastTimer tickCounter;
+			tickCounter.Start();
+
+			// Create the table
+			nRet = YieldingCreateTable( eSchemaCatalog, pRecordInfoDesired );
+			EXIT_ON_SQL_FAILURE( nRet );
+			tickCounter.End();
+			int nElapsedMilliseconds = tickCounter.GetDuration().GetMilliseconds();
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tCreated table: %s: %d millisec\n", pRecordInfoDesired->GetName(), nElapsedMilliseconds );
+		}
+		else
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t%s\n", pRecordInfoDesired->GetName() );
+	}
+
+	// find tables which are different
+	EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: # of specified tables that differ from schema in database: %d\n",
+		vecPRecordInfoActualDifferent.Count() );
+
+#ifdef _DEBUG
+	// are some different? if so, list their names only for now.
+	// This is in _debug only because it's useful for debugging the below loop,
+	// but spewey for everyday life (as long as the below loop is working).
+	if ( vecPRecordInfoActualDifferent.Count() > 0 ) 
+	{
+		FOR_EACH_VEC( vecPRecordInfoActualDifferent, i )
+		{
+			CRecordInfo *pRecordInfoActual = vecPRecordInfoActualDifferent[i];
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]:   table %s is different\n",
+				pRecordInfoActual->GetName() );
+		}
+	}
+#endif
+
+	pSchemaUpdate->m_bSkippedAChange = false;
+
+	// Alter any table which needs to be altered
+	for ( int iTable = 0; iTable < vecPRecordInfoActualDifferent.Count(); iTable++ )
+	{
+		CRecordInfo *pRecordInfoActual = vecPRecordInfoActualDifferent[iTable];
+		int iRecordInfoDesired = mapPRecordInfoDesired.Find( pRecordInfoActual->GetName() );
+		Assert( mapPRecordInfoDesired.InvalidIndex() != iRecordInfoDesired );
+		CRecordInfo *pRecordInfoDesired = mapPRecordInfoDesired[iRecordInfoDesired];
+
+		CUtlVector<const CColumnInfo *> vecPColumnInfoDesiredMissing;
+		CUtlVector<const CColumnInfo *> vecPColumnInfoActualDifferent;
+		CUtlVector<const CColumnInfo *> vecPColumnInfoActualUnknown;
+
+		// We know something is different between the actual & desired schema for this table, but don't yet know what
+
+		// Compare each column
+		for ( int iColumnDesired = 0; iColumnDesired < pRecordInfoDesired->GetNumColumns(); iColumnDesired ++ )
+		{
+			const CColumnInfo &columnInfoDesired = pRecordInfoDesired->GetColumnInfo( iColumnDesired );
+			int iColumnActual = -1;
+			bool bRet = pRecordInfoActual->BFindColumnByName( columnInfoDesired.GetName(), &iColumnActual );
+			if ( bRet )
+			{
+				const CColumnInfo &columnInfoActual = pRecordInfoActual->GetColumnInfo( iColumnActual );
+				if ( columnInfoActual.GetChecksum() != columnInfoDesired.GetChecksum() )
+				{
+					// The actual column is different than the desired column
+					vecPColumnInfoActualDifferent.AddToTail( &columnInfoActual );
+				}
+			}
+			else
+			{
+				// The desired column is missing from the actual table
+				vecPColumnInfoDesiredMissing.AddToTail( &columnInfoDesired );
+			}
+		}
+		for ( int iColumnActual = 0; iColumnActual < pRecordInfoActual->GetNumColumns(); iColumnActual ++ )
+		{
+			const CColumnInfo &columnInfoActual = pRecordInfoActual->GetColumnInfo( iColumnActual );
+			int iColumnDesired = -1;
+			bool bRet = pRecordInfoDesired->BFindColumnByName( columnInfoActual.GetName(), &iColumnDesired );
+			if ( !bRet )
+			{
+				// this column exists in the running schema, but not in the desired schema (e.g. old column)
+				vecPColumnInfoActualUnknown.AddToTail( &columnInfoActual );
+			}
+		}
+
+		if ( ( vecPColumnInfoDesiredMissing.Count() > 0 )  || ( vecPColumnInfoActualDifferent.Count() > 0 ) )
+		{
+			pSchemaUpdate->m_bConversionNeeded = true;
+			pSchemaUpdate->m_cTablesNeedingChange++;
+		}
+
+		// Add any desired columns which are missing from the actual schema
+		if ( vecPColumnInfoDesiredMissing.Count() > 0 )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\tDesired columns missing in table %s:\n", pRecordInfoActual->GetName() );
+
+			for ( int iColumn = 0; iColumn < vecPColumnInfoDesiredMissing.Count(); iColumn++ )
+			{
+				const CColumnInfo *pColumnInfoDesired = vecPColumnInfoDesiredMissing[iColumn];
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t\t%s\n", pColumnInfoDesired->GetName() );
+				if ( bDoConversion )
+				{
+					CFastTimer tickCounter;
+					tickCounter.Start();
+					// Add the column
+					nRet = YieldingAlterTableAddColumn( eSchemaCatalog, pRecordInfoActual, pColumnInfoDesired );
+					EXIT_ON_SQL_FAILURE( nRet );
+					tickCounter.End();
+					int nElapsedMilliseconds = tickCounter.GetDuration().GetMilliseconds();
+					EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t\t\tCreated column %s: %d millisec\n", pColumnInfoDesired->GetName(), nElapsedMilliseconds );
+				}
+			}
+		}
+
+		// Check for any stray indices that aren't found in the specification?
+		bool bIndexMismatch = false;
+		for ( int idx = 0 ; idx < pRecordInfoActual->GetIndexFieldCount() ; ++idx )
+		{
+			const FieldSet_t &fs = pRecordInfoActual->GetIndexFields()[idx];
+			if ( pRecordInfoDesired->FindIndex( pRecordInfoActual, fs ) >= 0 )
+				continue;
+			if ( pRecordInfoDesired->FindIndexByName( fs.GetIndexName() ) >= 0 )
+				continue; // we already handled this above
+			bIndexMismatch = true;
+
+			if ( idx == pRecordInfoActual->GetPKIndex() )
+			{
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tTable %s primary key in database differs from specification.\n",
+					pRecordInfoDesired->GetName() );
+				nRet = YieldingProcessUnsafeConversion( eSchemaCatalog,
+					CFmtStr("ALTER TABLE App%u.%s DROP CONSTRAINT %s", GGCBase()->GetAppID(), pRecordInfoActual->GetName(), fs.GetIndexName() ).String(),
+					CFmtStr("%s: remove old primary key.", pRecordInfoDesired->GetName() ).String() );
+				EXIT_ON_SQL_FAILURE( nRet );
+			}
+			else
+			{
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tTable %s index %s exists in database but is not in specification.  (Possible performance problem?).\n",
+					pRecordInfoDesired->GetName(), fs.GetIndexName() );
+				nRet = YieldingProcessUnsafeConversion( eSchemaCatalog,
+					CFmtStr("DROP INDEX %s ON App%u.%s", fs.GetIndexName(), GGCBase()->GetAppID(), pRecordInfoActual->GetName() ).String(),
+					CFmtStr("%s: cleanup stray index %s.", pRecordInfoDesired->GetName(), fs.GetIndexName() ).String() );
+				EXIT_ON_SQL_FAILURE( nRet );
+			}
+		}
+
+		// Change any columns which are different between desired and actual schema
+		if ( vecPColumnInfoActualDifferent.Count() > 0 )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tColumns that differ between specification and database in table %s:\n",
+				pRecordInfoActual->GetName() );
+			for ( int iColumn = 0; iColumn < vecPColumnInfoActualDifferent.Count(); iColumn++ )
+			{
+				const CColumnInfo *pColumnInfoActual = vecPColumnInfoActualDifferent[iColumn];
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t%s", pColumnInfoActual->GetName() );
+				int iColumnDesired = -1;
+				DbgVerify( pRecordInfoDesired->BFindColumnByName( pColumnInfoActual->GetName(), &iColumnDesired ) );
+				const CColumnInfo *pColumnInfoDesired = &pRecordInfoDesired->GetColumnInfo( iColumnDesired );
+
+				// if type or size changed, alter the column
+				if ( ( pColumnInfoDesired->GetType() != pColumnInfoActual->GetType() )  ||
+					// fixed length field, and the sizes differ
+					( ! pColumnInfoDesired->BIsVariableLength() && 
+					( pColumnInfoDesired->GetFixedSize() != pColumnInfoActual->GetFixedSize() ) ) ||
+					// variable length field, and the sizes differ
+					// fixed length field, and the sizes differ
+					( pColumnInfoDesired->BIsVariableLength() && 
+					( pColumnInfoDesired->GetMaxSize() != pColumnInfoActual->GetMaxSize() ) ) )
+				{
+					if ( k_EConversionModeConvertIrreversible != m_eConversionMode )
+					{
+						pSchemaUpdate->m_bSkippedAChange = true;
+						if ( pColumnInfoDesired->GetType() != pColumnInfoActual->GetType() )
+							EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t(data types differ: desired=%s, actual=%s)", PchNameFromEGCSQLType( pColumnInfoDesired->GetType() ), PchNameFromEGCSQLType( pColumnInfoActual->GetType() ) ); 
+						if ( pColumnInfoDesired->GetFixedSize() != pColumnInfoActual->GetFixedSize() )
+							EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t(column sizes differ: desired=%d, actual=%d)", pColumnInfoDesired->GetFixedSize(), pColumnInfoActual->GetFixedSize()  ); 
+						if ( pColumnInfoDesired->GetMaxSize() != pColumnInfoActual->GetMaxSize() )
+							EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t(maximum column sizes differ: desired=%d, actual=%d)", pColumnInfoDesired->GetMaxSize(), pColumnInfoActual->GetMaxSize()  ); 
+					}
+					nRet = YieldingChangeColumnTypeOrLength( eSchemaCatalog, pRecordInfoActual, pColumnInfoDesired );
+					EXIT_ON_SQL_FAILURE( nRet );
+				}
+
+				// If column constraints/indexes are different, make appropriate adjustments
+				// do this second so it has a chance to succeed - otherwise, we may create an index here that
+				// prevents us from performing an alter table
+				if ( pColumnInfoDesired->GetColFlags() != pColumnInfoActual->GetColFlags() )
+				{
+					if ( k_EConversionModeConvertIrreversible != m_eConversionMode )
+					{
+						char szDesiredFlags[k_nKiloByte];
+						char szActualFlags[k_nKiloByte];
+						pColumnInfoDesired->GetColFlagDescription( szDesiredFlags, Q_ARRAYSIZE( szDesiredFlags ) );
+						pColumnInfoActual->GetColFlagDescription( szActualFlags, Q_ARRAYSIZE( szActualFlags ) );
+
+						pSchemaUpdate->m_bSkippedAChange = true;
+						EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t(column flags differ: desired=\"%s\", actual=\"%s\")",
+							szDesiredFlags, szActualFlags );
+					}
+					nRet = YieldingChangeColumnProperties( eSchemaCatalog, pRecordInfoActual, pColumnInfoActual, pColumnInfoDesired );
+					EXIT_ON_SQL_FAILURE( nRet );
+				}
+
+				if ( pSchemaUpdate->m_bSkippedAChange )
+					EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t(Not attempting unsafe change).\n" );
+			}
+		}
+
+		// Scan for any new / changed indices
+		for ( int idx = 0 ; idx < pRecordInfoDesired->GetIndexFieldCount() ; ++idx )
+		{
+			const FieldSet_t &fs = pRecordInfoDesired->GetIndexFields()[idx];
+			int iActualIdx = pRecordInfoActual->FindIndex( pRecordInfoDesired, fs );
+			if ( iActualIdx >= 0 )
+				continue;
+			bIndexMismatch = true;
+
+			// The exact index we want doesn't exist.  Is it the primary key?
+			CUtlString sCommand;
+			CUtlString sComment;
+			if ( idx == pRecordInfoDesired->GetPKIndex() )
+			{
+					EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tTable %s primary key in specification differs from database.\n",
+						pRecordInfoDesired->GetName() );
+					sComment.Format( "%s: create new primary key constraint", pRecordInfoDesired->GetName() );
+					TSQLCmdStr cmd;
+					BuildTablePKConstraintText( &cmd, pRecordInfoDesired );
+					for ( int i = 0 ; i < fs.GetCount() ; ++i ) // make sure they are non-NULL
+					{
+						int idxField = fs.GetField(i);
+						const CColumnInfo *pColInfo = &pRecordInfoDesired->GetColumnInfo( idxField );
+						Assert( pColInfo->BIsPrimaryKey() );
+						sCommand += GetAlterColumnText( pRecordInfoDesired, pColInfo );
+						sCommand += ";\n";
+					}
+
+					CUtlString sCreatePK;
+					sCreatePK.Format( "GO\nALTER TABLE App%u.%s ADD %s\n", GGCBase()->GetAppID(), pRecordInfoDesired->GetName(), cmd.String() );
+					sCommand += sCreatePK;
+			}
+			else
+			{
+
+				// Another common thing that could happen is that an index is changed.
+				// Look for an existing index with the same name as a way to try to
+				// detect this common case and provide a more specific message.  (Otherwise,
+				// we will report it as a missing index, and an extra unwanted index --- which
+				// is correct but a bit more confusing.)
+
+				iActualIdx = pRecordInfoActual->FindIndexByName( fs.GetIndexName() );
+				if ( iActualIdx < 0 )
+				{
+					sComment.Format("%s: add index %s", pRecordInfoDesired->GetName(), fs.GetIndexName() );
+					EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tTable %s index %s is specified but not present in database.\n",
+						pRecordInfoDesired->GetName(), fs.GetIndexName() );
+				}
+				else
+				{
+					EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tTable %s index %s differs between specification and database.\n",
+						pRecordInfoDesired->GetName(), fs.GetIndexName() );
+					sComment.Format( "%s: fix index %s", pRecordInfoDesired->GetName(), fs.GetIndexName() );
+					sCommand.Format( "DROP INDEX %s ON App%u.%s;\n", fs.GetIndexName(), GGCBase()->GetAppID(), pRecordInfoDesired->GetName() );
+				}
+				sCommand += GetAddIndexSQL( pRecordInfoDesired, fs );
+			}
+			nRet = YieldingProcessUnsafeConversion( eSchemaCatalog, sCommand, sComment );
+			EXIT_ON_SQL_FAILURE( nRet );
+		}
+
+		// Just to be safe, let's run the old code, too.
+		if ( !bIndexMismatch && !pRecordInfoActual->CompareIndexLists( pRecordInfoDesired ) )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tIndex sets in table %s differ between specification and database [GC]:\n",
+				pRecordInfoDesired->GetName() );
+			CFmtStr1024 sTemp;
+
+			pRecordInfoDesired->GetIndexFieldList( &sTemp, 3 );
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\tDesired %s", sTemp.Access() );
+
+			pRecordInfoActual->GetIndexFieldList( &sTemp, 3 );
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\tActual %s", sTemp.Access() );
+		}
+
+		// what about foreign key constraints?
+		if ( ! pRecordInfoActual->CompareFKs( pRecordInfoDesired ) )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tForeign Key constraints in table %s differs between specification and database [GC]:\n",
+				pRecordInfoDesired->GetName() );
+
+			CFmtStr1024 sTemp;
+			pRecordInfoDesired->GetFKListString( &sTemp, 3 );
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\tDesired %s", sTemp.Access() );
+
+			pRecordInfoActual->GetFKListString( &sTemp, 3 );
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\tActual %s", sTemp.Access() );
+		}
+
+
+
+		if ( vecPColumnInfoActualUnknown.Count() > 0 )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tColumns in database [GC] table %s that are not in specification (ignored):\n",
+				pRecordInfoActual->GetName() );
+
+			// Since this can actually destroy data, let's not ever, ever run it automatically.
+			CUtlString sCommand;
+			sCommand.Format( "ALTER TABLE App%u.%s DROP COLUMN ", GGCBase()->GetAppID(), pRecordInfoActual->GetName() );
+
+			for ( int iColumn = 0; iColumn < vecPColumnInfoActualUnknown.Count(); iColumn++ )
+			{
+				const CColumnInfo *pColumnInfo = vecPColumnInfoActualUnknown[iColumn];
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t%s\n", pColumnInfo->GetName() );
+				if ( iColumn != 0 )
+					sCommand += ", ";
+				sCommand += pColumnInfo->GetName();
+			}
+			AddDataDestroyingConversion( sCommand,
+				CFmtStr( "-- Drop extra column(s) in %s\n", pRecordInfoActual->GetName() ) );
+		}
+
+		pSchemaUpdate->m_cColumnsDesiredMissing += vecPColumnInfoDesiredMissing.Count();
+		pSchemaUpdate->m_cColumnsActualDifferent += vecPColumnInfoActualDifferent.Count();
+		pSchemaUpdate->m_cColumnsActualUnknown += vecPColumnInfoActualUnknown.Count();
+	}
+
+	EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: # of tables that currently exist in database but were unspecified: %d\n", 
+		vecPRecordInfoActualUnknown.Count() );
+	for ( int iTable = 0; iTable < vecPRecordInfoActualUnknown.Count(); iTable++ )
+	{
+		CRecordInfo *pRecordInfo = vecPRecordInfoActualUnknown[iTable];
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t%s\n", pRecordInfo->GetName() );
+		AddDataDestroyingConversion(
+			CFmtStr( "DROP TABLE App%u.%s\n", GGCBase()->GetAppID(), pRecordInfo->GetName() ),
+			CFmtStr( "-- Drop extra table %s\n", pRecordInfo->GetName() ) );
+	}
+
+	// then, the triggers
+	if ( vecTriggerInfoMissing.Count() > 0 )
+	{
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: # of specified triggers that do not currently exist: %d\n",
+			vecTriggerInfoMissing.Count() );
+
+		FOR_EACH_VEC( vecTriggerInfoMissing, iMissing )
+		{
+			CFastTimer tickCounter;
+			tickCounter.Start();
+
+			// Create the trigger
+			nRet = YieldingCreateTrigger( eSchemaCatalog, vecTriggerInfoMissing[ iMissing] );
+			EXIT_ON_SQL_FAILURE( nRet );
+			tickCounter.End();
+			int nElapsedMilliseconds = tickCounter.GetDuration().GetMilliseconds();
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: Created trigger %s on table %s: %d millisec\n",
+				vecTriggerInfoMissing[ iMissing ].m_szTriggerName,
+				vecTriggerInfoMissing[ iMissing ].m_szTriggerTableName, nElapsedMilliseconds );
+		}
+	}
+
+	// different triggers
+	FOR_EACH_VEC( vecTriggerInfoDifferent, iDifferent )
+	{
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: Trigger %s on table %s differs from the desired trigger\n", vecTriggerInfoMissing[ iDifferent ].m_szTriggerName,
+			vecTriggerInfoMissing[ iDifferent ].m_szTriggerTableName);
+
+		// a different trigger text is a forced failure.
+		nRet = SQL_ERROR;
+	}
+
+	// extra triggers
+	FOR_EACH_VEC( vecTriggerInfoActual, iActual )
+	{
+		// if it was never matched, it isn't in the schema anywhere
+		if ( ! vecTriggerInfoActual[ iActual ].m_bMatched )
+		{
+			SQLRETURN nSQLReturn = YieldingDropTrigger( eSchemaCatalog, vecTriggerInfoActual[ iActual ] );
+
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: Trigger %s on table %s is not in the declared schema ... Drop %s",
+				vecTriggerInfoActual[ iActual ].m_szTriggerName,
+				vecTriggerInfoActual[ iActual ].m_szTriggerTableName,
+				SQL_OK( nSQLReturn ) ? "OK" : "FAILED!" ) ;
+
+			if ( !SQL_OK ( nSQLReturn ) )
+			{
+				// it broke; latch the failure
+				nRet = nSQLReturn;
+			}
+		}
+	}
+
+	tickCounterOverall.End();
+	EmitAndAppend( sDetail, SPEW_GC, 2, 2, "[GC]: Total time: %d milliseconds\n",
+		tickCounterOverall.GetDuration().GetMilliseconds() );
+
+Exit:
+
+	// Spew suggested SQL to clean up stuff
+	if ( !m_sRecommendedSQL.IsEmpty() || !m_sDataDestroyingCleanupSQL.IsEmpty() )
+	{
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\tThe following SQL might work to fixup schema differences.\n" );
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t** \n" );
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t** DISCLAIMER ** This conversion code is not well tested.  Review the SQL and use at your own risk.\n" );
+		EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t** \n" );
+		{
+			CUtlVectorAutoPurge<char*> vecLines;
+			V_SplitString( m_sRecommendedSQL, "\n", vecLines );
+			FOR_EACH_VEC( vecLines, i )
+			{
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t%s\n", vecLines[i] );
+			}
+			m_sRecommendedSQL.Clear();
+		}
+		if ( !m_sDataDestroyingCleanupSQL.IsEmpty() )
+		{
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t-- WARNING: The following operations will *destroy* data that is in the database but not in the specification.\n" );
+			EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t--          If you have manually created extra tables or columns in your database, it will appear here!\n" );
+			CUtlVectorAutoPurge<char*> vecLines;
+			V_SplitString( m_sDataDestroyingCleanupSQL, "\n", vecLines );
+			FOR_EACH_VEC( vecLines, i )
+			{
+				EmitAndAppend( sDetail, SPEW_GC, 2, 2, "\t\t%s\n", vecLines[i] );
+			}
+			m_sDataDestroyingCleanupSQL.Clear();
+		}
+	}
+
+	pSchemaUpdate->m_cTablesDesiredMissing = vecPRecordInfoDesiredMissing.Count();
+	pSchemaUpdate->m_cTablesActualDifferent = vecPRecordInfoActualDifferent.Count();
+	pSchemaUpdate->m_cTablesActualUnknown = vecPRecordInfoActualUnknown.Count();
+
+	FOR_EACH_MAP_FAST( mapPRecordInfoActual, iRecordInfoActual )
+		SAFE_RELEASE( mapPRecordInfoActual[iRecordInfoActual] );
+
+	return nRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a record info for each table in database that describes the
+//			columns in that table
+// Input:	pSQLConnection - SQL connection to execute on
+//			mapPRecordInfo - map to add the table record infos to
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingGetSchemaID( ESchemaCatalog eSchemaCatalog, int *pSchemaID )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	CFmtStr1024 sDefaultSchema;
+	if( !sqlAccess.BYieldingExecuteString( FILE_AND_LINE, "SELECT default_schema_name FROM sys.database_principals WHERE name=CURRENT_USER",
+		&sDefaultSchema ) )
+		return SQL_ERROR;
+
+	CFmtStr sExpectedDefaultSchema( "App%u", GGCBase()->GetAppID() );
+	if ( 0 != Q_stricmp( sDefaultSchema, sExpectedDefaultSchema ) )
+	{
+		AssertMsg2( false, "SQL connection has the wrong default schema. Expected: %s. Actual %s", sExpectedDefaultSchema.Get(), sDefaultSchema.Get() );
+		return SQL_ERROR;
+	}
+
+	sqlAccess.AddBindParam( sDefaultSchema );
+	if( !sqlAccess.BYieldingExecuteScalarInt( FILE_AND_LINE, "SELECT SCHEMA_ID(?)", pSchemaID ) )
+		return SQL_ERROR;
+
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a record info for each table in database that describes the
+//			columns in that table
+// Input:	pSQLConnection - SQL connection to execute on
+//			mapPRecordInfo - map to add the table record infos to
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingGetRecordInfoForAllTables( ESchemaCatalog eSchemaCatalog, int nSchemaID, CMapPRecordInfo &mapPRecordInfo )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	// create a query that returns all tables in the database
+	sqlAccess.AddBindParam( nSchemaID );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, "SELECT object_id, name FROM sys.objects WHERE type_desc = 'USER_TABLE' AND is_ms_shipped = 0 AND schema_id = ?" ) );
+
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, tableIDRecord )
+	{
+		int nTableID;
+		RETURN_SQL_ERROR_ON_FALSE( tableIDRecord.BGetIntValue( 0, &nTableID ) );
+
+		CFmtStr1024 sTableName;
+		RETURN_SQL_ERROR_ON_FALSE( tableIDRecord.BGetStringValue( 1, &sTableName) );
+
+		YieldingGetColumnInfoForTable( eSchemaCatalog, mapPRecordInfo, nTableID, sTableName );
+	}
+
+
+	// now, get the column indexes and constraints for each table
+	FOR_EACH_MAP_FAST( mapPRecordInfo, iRecordInfo )
+	{
+		CRecordInfo *pRecordInfo = mapPRecordInfo[iRecordInfo];
+		pRecordInfo->SetAllColumnsAdded();
+
+		// determine indexes and constraints
+		YieldingGetColumnIndexes( eSchemaCatalog, pRecordInfo );
+
+		// determine FK constraints
+		YieldingGetTableFKConstraints( eSchemaCatalog, pRecordInfo );
+
+		// do final calculations then ready to use
+		pRecordInfo->PrepareForUse();
+	}
+
+	return SQL_SUCCESS;
+}
+
+SQLRETURN CJobUpdateSchema::YieldingGetColumnInfoForTable( ESchemaCatalog eSchemaCatalog, CMapPRecordInfo &mapPRecordInfo, int nTableID, const char *pchTableName )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	sqlAccess.AddBindParam( nTableID );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, "SELECT name, column_id, user_type_id, max_length, is_identity FROM sys.columns WHERE object_id = ?") );
+
+	CRecordInfo *pRecordInfo = CRecordInfo::Alloc();
+	pRecordInfo->SetName( pchTableName );
+	pRecordInfo->SetTableID( nTableID );
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, columnInfo )
+	{
+		CFmtStr1024 sColumnName;
+		int nType;
+		int nColumnID;
+		int nMaxLength;
+		bool bIdentity;
+		RETURN_SQL_ERROR_ON_FALSE( columnInfo.BGetStringValue( 0, &sColumnName) );
+		RETURN_SQL_ERROR_ON_FALSE( columnInfo.BGetIntValue( 1, &nColumnID ) );
+		RETURN_SQL_ERROR_ON_FALSE( columnInfo.BGetIntValue( 2, &nType ) );
+		RETURN_SQL_ERROR_ON_FALSE( columnInfo.BGetIntValue( 3, &nMaxLength ) );
+		RETURN_SQL_ERROR_ON_FALSE( columnInfo.BGetBoolValue( 4, &bIdentity) );
+
+		int nColFlags = 0;
+		if( bIdentity )
+			nColFlags |= k_nColFlagAutoIncrement;
+
+		pRecordInfo->AddColumn( sColumnName, nColumnID, GetEGCSQLTypeForMSSQLType( nType ), nMaxLength, nColFlags, nMaxLength );
+	}
+	mapPRecordInfo.Insert( pRecordInfo->GetName(), pRecordInfo );
+
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// purpose: get a list of triggers from the database.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingGetTriggers( ESchemaCatalog eSchemaCatalog, int nSchemaID, CUtlVector< CTriggerInfo > &vecTriggerInfo )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	// get some description and the text of the triggers on this database.
+	// Find the name of the trigger, the name of the table it servers, the type of
+	// trigger, and its text. Doesn't bring back any disabled or MS-shipped triggers,
+	// and gets only DML triggers and not DDL triggers.
+	const char *pchStatement = "SELECT ST.name AS TriggerName, SOT.name AS TableName, ST.is_instead_of_trigger, SC.Text, SC.ColID"
+		"  FROM sys.triggers AS ST"
+		"  JOIN sys.syscomments AS SC ON SC.id = ST.object_id"
+		"  JOIN sys.objects AS SO ON SO.object_id = ST.object_id"
+		"  JOIN sys.objects AS SOT on SOT.object_id = ST.parent_id"
+		" WHERE ST.type_desc = 'SQL_TRIGGER'"
+		"   AND ST.is_ms_shipped = 0 AND ST.is_disabled = 0"
+		"   AND ST.parent_class = 1"
+		"   AND SO.schema_id = ?"
+		" ORDER BY TableName, TriggerName, SC.ColID";
+	sqlAccess.AddBindParam( nSchemaID );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, pchStatement ) );
+
+	// should be one results set
+	Assert( 1 == sqlAccess.GetResultSetCount() );
+
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, sqlRecord )
+	{
+		// get the text of the procedure
+		const char *pchText;
+		DbgVerify( sqlRecord.BGetStringValue( 3, &pchText ) );
+
+		// is this instead of?
+		bool bIsInsteadOf;
+		DbgVerify( sqlRecord.BGetBoolValue( 2, &bIsInsteadOf ) );
+
+		// get the table name
+		const char *pchTableName;
+		DbgVerify( sqlRecord.BGetStringValue( 1, &pchTableName ) );
+
+		// and the trigger name
+		const char *pchTriggerName;
+		DbgVerify( sqlRecord.BGetStringValue( 0, &pchTriggerName ) );
+
+		// finally, grab the collation id
+		int16 nColID;
+		DbgVerify( sqlRecord.BGetInt16Value( 4, &nColID ) );
+
+		if ( nColID == 1 )
+		{
+			// the collation ID is one, so we know this is a new one
+			CTriggerInfo info;
+			info.m_strText = pchText;
+			Q_strncpy( info.m_szTriggerName, pchTriggerName, Q_ARRAYSIZE( info.m_szTriggerName ) );
+			Q_strncpy( info.m_szTriggerTableName, pchTableName, Q_ARRAYSIZE( info.m_szTriggerTableName ) );
+			info.m_eSchemaCatalog = eSchemaCatalog;
+			vecTriggerInfo.AddToTail( info );
+		}
+		else
+		{
+			// the collation ID is not one, so we're concatenating.
+			Assert( vecTriggerInfo.Count() - 1 >= 0 );
+
+			// the name could not have changed
+			Assert( 0 == Q_strcmp( vecTriggerInfo[vecTriggerInfo.Count() - 1].m_szTriggerName, pchTriggerName ) );
+		}
+	}
+
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: retrieves the index information for the specified table, then adds this
+//			information to the record info. This is a SQL Server-specific implementation
+//			which gets data describing index features not available through plain ODBC
+//			queries.
+// Input:	pSQLConnection - SQL connection to execute on
+//			pRecordInfo - CRecordInfo to add the index info into
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingGetColumnIndexes( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo )
+{
+	// query the system management views for all of the indexes on this table
+	static const char *pstrStatement = 
+		"SELECT SI.Name AS INDEX_NAME, SC.Name AS COLUMN_NAME, SI.Type AS [TYPE], IS_INCLUDED_COLUMN, SIC.KEY_Ordinal AS [ORDINAL_POSITION], IS_UNIQUE, IS_PRIMARY_KEY, SI.INDEX_ID"
+		"  FROM sys.indexes SI "
+		"  JOIN sys.index_columns SIC"
+		"		ON SIC.Object_id = SI.Object_Id"
+		"			AND SIC.Index_ID = SI.Index_id"
+		"  JOIN sys.objects SO"
+		"		ON SIC.Object_ID = SO.Object_ID"
+		"  JOIN sys.columns SC"
+		"		ON SC.Object_ID = SO.Object_ID"
+		"			AND SC.column_id = SIC.column_id"
+		" WHERE SO.Object_ID = ? "
+		"ORDER BY SIC.Index_id, SIC.Key_Ordinal ";
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	sqlAccess.AddBindParam( pRecordInfo->GetTableID() );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, pstrStatement ) );
+
+	// builds a list of columns in a particular index.
+	CUtlVector<int> vecColumns;
+	CUtlVector<int> vecIncluded;
+	int nLastIndexID = -1;
+	bool bIsClustered = false;
+	bool bIsIndexUnique = false;
+	bool bIsPrimaryKey = false;
+	CFmtStr1024 sIndexName, sColumnName;
+
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, typeRecord )
+	{
+		// Starting a new index?
+		int nIndexID;
+		DbgVerify( typeRecord.BGetIntValue( 7, &nIndexID ) );
+		if ( nIndexID != nLastIndexID )
+		{
+			// first column! is it our first time through?
+			if ( vecColumns.Count() > 0 )
+			{
+				// yes. let's add what we had from the previous index
+				// to the fieldset
+				FieldSet_t fs( bIsIndexUnique, bIsClustered, vecColumns, sIndexName );
+				fs.AddIncludedColumns( vecIncluded );
+				int idx = pRecordInfo->AddIndex( fs );
+				if ( bIsPrimaryKey )
+				{
+					Assert( bIsIndexUnique );
+					Assert( pRecordInfo->GetPKIndex() < 0 );
+					pRecordInfo->SetPKIndex( idx );
+				}
+
+				// reset the vector
+				vecColumns.RemoveAll();
+				vecIncluded.RemoveAll();
+				bIsIndexUnique = false;
+				bIsClustered = false;
+				bIsPrimaryKey = false;
+			}
+			nLastIndexID = nIndexID;
+		}	
+
+		int nTypeID, nOrdinalPosition;
+		bool bIsIncluded, bIsColumnUnique;
+
+		DbgVerify( typeRecord.BGetStringValue( 0, &sIndexName ) );
+		DbgVerify( typeRecord.BGetStringValue( 1, &sColumnName ) );
+		DbgVerify( typeRecord.BGetIntValue( 2, &nTypeID ) );
+		DbgVerify( typeRecord.BGetBoolValue( 3, &bIsIncluded ) );
+		DbgVerify( typeRecord.BGetIntValue( 4, &nOrdinalPosition ) );
+		DbgVerify( typeRecord.BGetBoolValue( 5, &bIsColumnUnique ) );
+		DbgVerify( typeRecord.BGetBoolValue( 6, &bIsPrimaryKey ) );
+
+		RETURN_SQL_ERROR_ON_FALSE( sColumnName.Length() > 0 );
+
+		int nColumnIndexed = -1;
+		RETURN_SQL_ERROR_ON_FALSE( pRecordInfo->BFindColumnByName( sColumnName, &nColumnIndexed ) );
+
+		CColumnInfo & columnInfo = pRecordInfo->GetColumnInfo( nColumnIndexed );
+		int nColFlags = 0;
+
+		if ( bIsIncluded )
+		{
+			Assert( nOrdinalPosition == 0 );
+			// it's included; no flags
+			vecIncluded.AddToTail( nColumnIndexed );
+		}
+		else
+		{
+			Assert( nOrdinalPosition != 0 );
+			if ( bIsPrimaryKey )
+			{
+				// if we're working a primary key, mark those flags
+				nColFlags = k_nColFlagPrimaryKey | k_nColFlagIndexed | k_nColFlagUnique;
+				// PKs are always unique
+				bIsIndexUnique = true;
+			}
+			else
+			{
+				// if we're working a "regular" index, we need to know the uniqueness of the index ...
+
+				nColFlags = k_nColFlagIndexed;
+				if ( bIsColumnUnique )
+				{
+					nColFlags |= k_nColFlagUnique;
+					bIsIndexUnique = true;
+				}
+			}
+
+			// clustering type
+			if ( nTypeID == SQL_INDEX_CLUSTERED )
+			{
+				nColFlags |= k_nColFlagClustered;
+				bIsClustered = true;
+			}
+			columnInfo.SetColFlagBits( nColFlags );
+
+			// add this column to our list for the index set
+			vecColumns.AddToTail( nColumnIndexed );
+		}
+	}
+
+	// anything left over?
+	if ( vecColumns.Count() > 0 )
+	{
+		// yep, add that, too
+		FieldSet_t fs( bIsIndexUnique, bIsClustered, vecColumns, sIndexName );
+		fs.AddIncludedColumns( vecIncluded );
+		int idx = pRecordInfo->AddIndex( fs );
+		if ( bIsPrimaryKey )
+		{
+			Assert( bIsIndexUnique );
+			Assert( pRecordInfo->GetPKIndex() < 0 );
+			pRecordInfo->SetPKIndex( idx );
+		}
+	}
+
+	return SQL_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds the schema info on any FK constraints defined for the table
+// Input:	pRecordInfo - CRecordInfo to add the index info into (and lookup table name out of)
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingGetTableFKConstraints( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo )
+{
+	// Used below, declared up here because of goto
+	FKData_t fkData;
+
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	const char *pchStatement =  "SELECT fk.name AS FKName, current_table.name AS TableName, parent_table.name AS ParentTableName, "
+		"table_column.name AS ColName, parent_table_column.name AS ParentColName, "
+		"fk.delete_referential_action_desc AS OnDelete, "
+		"fk.update_referential_action_desc AS OnUpdate "
+		"FROM sys.objects AS current_table "
+		"JOIN sys.foreign_keys AS fk ON fk.parent_object_id=current_table.object_id AND fk.is_ms_shipped=0 "
+		"JOIN sys.foreign_key_columns AS fk_col ON fk_col.constraint_object_id=fk.object_id "
+		"JOIN sys.objects AS parent_table ON parent_table.object_id=fk_col.referenced_object_id "
+		"JOIN sys.columns AS table_column ON table_column.object_id=fk_col.parent_object_id AND table_column.column_id=fk_col.parent_column_id "
+		"JOIN sys.columns AS parent_table_column ON parent_table_column.object_id=fk_col.referenced_object_id AND parent_table_column.column_id=fk_col.referenced_column_id "
+		"WHERE current_table.object_id = ? ORDER BY fk.name";
+	sqlAccess.AddBindParam( pRecordInfo->GetTableID() );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, pchStatement ) );
+
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, sqlRecord )
+	{
+		// get all the data for the FK
+		const char *pchFKName;
+		DbgVerify( sqlRecord.BGetStringValue( 0, &pchFKName ) );
+
+		const char *pchTableName;
+		DbgVerify( sqlRecord.BGetStringValue( 1, &pchTableName ) );
+
+		AssertMsg( Q_stricmp( pchTableName, pRecordInfo->GetName() ) == 0, "FOREIGN KEY schema conversion found FK for table not matching search!\n" );
+
+		const char *pchParentTable;
+		DbgVerify( sqlRecord.BGetStringValue( 2, &pchParentTable ) );
+
+		const char *pchColName;
+		DbgVerify( sqlRecord.BGetStringValue( 3, &pchColName ) );
+
+		const char *pchParentColName;
+		DbgVerify( sqlRecord.BGetStringValue( 4, &pchParentColName ) );
+
+		const char *pchOnDelete;
+		DbgVerify( sqlRecord.BGetStringValue( 5, &pchOnDelete ) );
+
+		const char *pchOnUpdate;
+		DbgVerify( sqlRecord.BGetStringValue( 6, &pchOnUpdate ) );
+
+		// Is this more data for the FK we are already tracking?  If so just append the column data,
+		// otherwise, assuming some data exists, add the key to the record info
+		if ( Q_strcmp( fkData.m_rgchName, pchFKName ) == 0 )
+		{
+			int iColRelation = fkData.m_VecColumnRelations.AddToTail();
+			FKColumnRelation_t &colRelation = fkData.m_VecColumnRelations[iColRelation];
+			Q_strncpy( colRelation.m_rgchCol, pchColName, Q_ARRAYSIZE( colRelation.m_rgchCol ) );
+			Q_strncpy( colRelation.m_rgchParentCol, pchParentColName, Q_ARRAYSIZE( colRelation.m_rgchParentCol ) );
+		}
+		else 
+		{
+			if ( Q_strlen( fkData.m_rgchName ) )
+			{	
+				pRecordInfo->AddFK( fkData  );
+			}
+
+			// Do initial setup of the new key
+			Q_strncpy( fkData.m_rgchName, pchFKName, Q_ARRAYSIZE( fkData.m_rgchName ) );
+			Q_strncpy( fkData.m_rgchParentTableName, pchParentTable, Q_ARRAYSIZE( fkData.m_rgchParentTableName ) );
+			fkData.m_eOnDeleteAction = EForeignKeyActionFromName( pchOnDelete ); 
+			fkData.m_eOnUpdateAction = EForeignKeyActionFromName( pchOnUpdate );
+			int iColRelation = fkData.m_VecColumnRelations.AddToTail();
+			FKColumnRelation_t &colRelation = fkData.m_VecColumnRelations[iColRelation];
+			Q_strncpy( colRelation.m_rgchCol, pchColName, Q_ARRAYSIZE( colRelation.m_rgchCol ) );
+			Q_strncpy( colRelation.m_rgchParentCol, pchParentColName, Q_ARRAYSIZE( colRelation.m_rgchParentCol ) );
+		}
+	}
+
+
+	// Add the last key we were building data for
+	if ( Q_strlen( fkData.m_rgchName ) )
+	{
+		pRecordInfo->AddFK( fkData  );
+	}
+
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a table in the DB to match the recordinfo
+// Input:	pRecordInfo - CRecordInfo to create a table for
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingCreateTable( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo )
+{
+	CFmtStrMax sCmd;
+	SQLRETURN nRet = 0;
+	const char *pchName = pRecordInfo->GetName();
+	Assert( pchName && pchName[0] );
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	// build the create table command
+	sCmd.sprintf( "CREATE TABLE %s (", pchName );
+
+	// add all the columns
+	for ( int iColumn = 0; iColumn < pRecordInfo->GetNumColumns(); iColumn++ )
+	{
+		char rgchType[k_cSmallBuff];
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+		char *pchType = SQLTypeFromField( columnInfo, rgchType, Q_ARRAYSIZE( rgchType ) );
+		Assert( pchType[0] );
+
+		// add the name and type of this column
+		sCmd.AppendFormat( "%s %s", columnInfo.GetName(), pchType );
+
+		// add any constraints
+		AppendConstraints( pRecordInfo, &columnInfo, true, sCmd );
+
+		if ( iColumn < ( pRecordInfo->GetNumColumns() - 1 ) )
+			sCmd += ", ";
+	}
+
+	AppendTableConstraints( pRecordInfo, sCmd );
+	sCmd += ")";
+
+
+	// create the table
+	// metadata operations aren't transactional, so we'll set bAutoTransaction = true
+	EXIT_ON_BOOLSQL_FAILURE( sqlAccess.BYieldingExecute( FILE_AND_LINE, sCmd ) );
+
+	// add any indexes
+	for ( int n = 0; n < pRecordInfo->GetIndexFields( ).Count(); n++ )
+	{
+		const FieldSet_t& refSet = pRecordInfo->GetIndexFields( )[ n ];
+
+		// already added the PK index, so skip it
+		if ( n == pRecordInfo->GetPKIndex() )
+			continue;
+
+		// call YieldingAddIndex to do the work
+		nRet = YieldingAddIndex( eSchemaCatalog, pRecordInfo, refSet );
+		EXIT_ON_SQL_FAILURE( nRet );
+	}
+
+Exit:
+	return nRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds an index of multiple columns to a table.
+// Input:	pSQLConnection - connection to use for command
+//			pRecordInfo - record info describing table
+//			refFields - description of index to add
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingAddIndex( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo, const FieldSet_t &refFields )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	CUtlString sCmd = GetAddIndexSQL( pRecordInfo, refFields );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, sCmd ) );
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Depending on the conversion mode, either really perfom the
+//          conversion, or just log the SQL text so a human being can review
+//          it and do it later.
+//-----------------------------------------------------------------------------
+
+SQLRETURN CJobUpdateSchema::YieldingProcessUnsafeConversion( ESchemaCatalog eSchemaCatalog, const char *pszSQL, const char *pszComment )
+{
+	if ( k_EConversionModeConvertIrreversible != m_eConversionMode )
+	{
+		if ( pszComment )
+		{
+			m_sRecommendedSQL.Append( "-- " );
+			m_sRecommendedSQL.Append( pszComment );
+			m_sRecommendedSQL.Append( "\n" );
+		}
+		m_sRecommendedSQL.Append( pszSQL );
+		m_sRecommendedSQL.Append("\nGO\n \n"); // that space is a kludge, because we are using V_splitlines, which will ignore consecutive seperators
+		return SQL_SUCCESS;
+	}
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, pszSQL ) );
+	return SQL_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a SQL command to cleanup the schema that will actually destroy (supposedly unused) data.
+//-----------------------------------------------------------------------------
+
+void CJobUpdateSchema::AddDataDestroyingConversion( const char *pszSQL, const char *pszComment )
+{
+	if ( pszComment )
+	{
+		m_sDataDestroyingCleanupSQL.Append( "-- " );
+		m_sDataDestroyingCleanupSQL.Append( pszComment );
+		m_sDataDestroyingCleanupSQL.Append( "\n" );
+	}
+	m_sDataDestroyingCleanupSQL.Append( pszSQL );
+	m_sDataDestroyingCleanupSQL.Append("\nGO\n \n"); // that space is a kludge, because we are using V_splitlines, which will ignore consecutive seperators
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a column to a table
+// Input:	pRecordInfo - record info describing table to add a column to
+//			pColumnInfo - column info describing column to add
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingAlterTableAddColumn( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfo )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	CFmtStrMax sCmd;
+	char rgchType[k_cSmallBuff];
+	const char *pchTableName = pRecordInfo->GetName();
+	Assert( pchTableName );
+	const char *pchColumnName = pColumnInfo->GetName();
+	Assert( pchColumnName );
+	DbgVerify( SQLTypeFromField( *pColumnInfo, rgchType, Q_ARRAYSIZE( rgchType ) )[0] );
+
+	// build the alter table command
+	sCmd.sprintf( "ALTER TABLE %s ADD %s %s", pchTableName, pchColumnName, rgchType );
+
+	// add any constraints
+	AppendConstraints( pRecordInfo, pColumnInfo, true, sCmd );
+
+	// !KLUDGE! This is guaranteed to fail if it has "not null" in it.
+	if ( V_strstr( sCmd, "NOT NULL" ) )
+	{
+		EmitError( SPEW_SQL, "Cannot add column %s to table %s with NOT NULL constraint\n", pchColumnName, pchTableName );
+		EmitInfo( SPEW_SQL, SPEW_ALWAYS, LOG_ALWAYS, "Here is the SQL that should be run to add the column:\n" );
+		EmitInfo( SPEW_SQL, SPEW_ALWAYS, LOG_ALWAYS, "  %s\n", sCmd.String() );
+		return SQL_ERROR;
+	}
+
+	// execute the command.
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, sCmd ) );
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a constraint to an existing column
+// Input:	hDBC - SQL connection to execute on
+//			pRecordInfo - record info describing table
+//			pColumnInfo - column info describing column to add contraint for
+//			nColFlagConstraint - constraint to add
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingAddConstraint( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfo, int nColFlagConstraint )
+{
+	Assert( pRecordInfo );
+	Assert( pColumnInfo );
+
+	CFmtStrMax sCmd;
+	sCmd.sprintf( "ALTER TABLE App%u.%s ADD", GGCBase()->GetAppID(), pRecordInfo->GetName() );
+
+	Assert( !pColumnInfo->BIsClustered() );
+	AppendConstraint( pRecordInfo->GetName(), pColumnInfo->GetName(), nColFlagConstraint, true, pColumnInfo->BIsClustered(), sCmd, 0 );
+
+	sCmd.AppendFormat( " (%s)", pColumnInfo->GetName() );
+
+	return YieldingProcessUnsafeConversion( eSchemaCatalog, sCmd );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Changes type or length of existing column
+// Input:	hDBC - SQL connection to execute on
+//			pRecordInfo - record info describing table
+//			pColumnInfoDesired - column info describing new column type or length
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingChangeColumnTypeOrLength( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfoDesired )
+{
+	CUtlString sCmd = GetAlterColumnText( pRecordInfo, pColumnInfoDesired );
+	return YieldingProcessUnsafeConversion( eSchemaCatalog, sCmd );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Changes constraints/indexes on a column
+// Input:	hDBC - SQL connection to execute on
+//			pRecordInfo - record info describing table
+//			pColumnInfoActual - column info describing existing column properties
+//			pColumnInfoActual - column info describing desired new column properties
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingChangeColumnProperties( ESchemaCatalog eSchemaCatalog, CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfoActual, 
+											 const CColumnInfo *pColumnInfoDesired )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	Assert( pRecordInfo );
+	Assert( pColumnInfoActual );
+	Assert( pColumnInfoDesired );
+
+	SQLRETURN nRet = SQL_SUCCESS;
+
+	pColumnInfoActual->ValidateColFlags();
+	pColumnInfoDesired->ValidateColFlags();
+
+	Assert( pColumnInfoActual->GetColFlags() != pColumnInfoDesired->GetColFlags() );
+
+	// all the operations we might have to perform; note we have have to drop one
+	// thing and add another
+	bool bAddExplicitIndex = false, bRemoveExplicitIndex = false;
+	bool bAddUniqueConstraint = false, bRemoveUniqueConstraint = false;
+	bool bAddPrimaryKeyConstraint = false, bRemovePrimaryKeyConstraint = false;
+
+	// determine which operations need to be performed
+	if ( !pColumnInfoActual->BIsPrimaryKey() && pColumnInfoDesired->BIsPrimaryKey() )
+	{
+		bAddPrimaryKeyConstraint = true;
+	}
+	else if ( pColumnInfoActual->BIsPrimaryKey() && !pColumnInfoDesired->BIsPrimaryKey() )
+	{
+		bRemovePrimaryKeyConstraint = true;
+	}
+
+	if ( !pColumnInfoActual->BIsExplicitlyUnique() && pColumnInfoDesired->BIsExplicitlyUnique() )
+	{
+		bAddUniqueConstraint = true;
+	}
+	else if ( pColumnInfoActual->BIsExplicitlyUnique() && !pColumnInfoDesired->BIsExplicitlyUnique() )
+	{
+		bRemoveUniqueConstraint = true;
+	}
+
+	if ( !pColumnInfoActual->BIsExplicitlyIndexed() && pColumnInfoDesired->BIsExplicitlyIndexed() )
+	{
+		bAddExplicitIndex = true;
+	}
+	else if ( pColumnInfoActual->BIsExplicitlyIndexed() && !pColumnInfoDesired->BIsExplicitlyIndexed() )
+	{
+		bRemoveExplicitIndex = true;
+	}
+
+	// sanity check 
+	Assert( !( bAddUniqueConstraint && bAddPrimaryKeyConstraint ) );	// primary key constraint adds implicit uniqueness constraint; it's a bug if we decide to do both
+	Assert( !( bAddUniqueConstraint && bAddExplicitIndex ) );	// uniqueness constraint adds implicit index; it's a bug if we decide to do both
+	Assert( !( bAddPrimaryKeyConstraint && bAddExplicitIndex ) );	// primary key constraint adds implicit index; it's a bug if we decide to do both
+
+	// The index conversion stuff already handles dropping of unexpected indices
+	// and primary key constraints.  I'm not even sure that this works or is used anymore.
+	if ( bAddUniqueConstraint )
+	{
+		nRet = YieldingAddConstraint( eSchemaCatalog, pRecordInfo, pColumnInfoActual, k_nColFlagUnique );
+		EXIT_ON_SQL_FAILURE( nRet );
+	}
+
+Exit:
+	return nRet;
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates specified trigger
+// Input:	pSQLConnection - SQL connection to execute on
+//			refTriggerInfo - trigger to be created
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingCreateTrigger( ESchemaCatalog eSchemaCatalog, CTriggerInfo &refTriggerInfo )
+{
+	char rgchCmd[ k_cchSQLStatementTextMax];
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	// build the create command
+	Q_snprintf( rgchCmd, Q_ARRAYSIZE( rgchCmd ),
+		"CREATE TRIGGER [%s] ON [%s] "
+		"%s "
+		"AS BEGIN"
+		"%s\n"
+		"END",
+		refTriggerInfo.m_szTriggerName,
+		refTriggerInfo.m_szTriggerTableName,
+		refTriggerInfo.GetTriggerTypeString(), 
+		refTriggerInfo.m_strText.Get() );
+
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, rgchCmd ) );
+	return SQL_SUCCESS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: drops specified trigger
+// Input:	pSQLConnection - SQL connection to execute on
+//			refTriggerInfo - trigger to be dropped
+// Output:  SQL return code.
+//-----------------------------------------------------------------------------
+SQLRETURN CJobUpdateSchema::YieldingDropTrigger( ESchemaCatalog eSchemaCatalog, CTriggerInfo &refTriggerInfo )
+{
+	char rgchCmd[ k_cchSQLStatementTextMax];
+	CSQLAccess sqlAccess( eSchemaCatalog );
+
+	// build the create command
+	Q_snprintf( rgchCmd, Q_ARRAYSIZE( rgchCmd ),
+		"DROP TRIGGER [%s];",
+		refTriggerInfo.m_szTriggerName );
+
+	RETURN_SQL_ERROR_ON_FALSE( sqlAccess.BYieldingExecute( FILE_AND_LINE, rgchCmd ) );
+	return SQL_SUCCESS;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for SQL/EGCSQLType conversion
+//-----------------------------------------------------------------------------
+struct SQLTypeMapping_t
+{
+	const char *m_pchTypeName;
+	EGCSQLType m_eType;
+};
+
+static SQLTypeMapping_t g_rSQLTypeMapping[] =
+{
+	{ "tinyint", k_EGCSQLType_int8 },
+	{ "smallint", k_EGCSQLType_int16 },
+	{ "int", k_EGCSQLType_int32 },
+	{ "bigint", k_EGCSQLType_int64 },
+	{ "real", k_EGCSQLType_float },
+	{ "float", k_EGCSQLType_double },
+	{ "text", k_EGCSQLType_String },
+	{ "ntext", k_EGCSQLType_String },
+	{ "char", k_EGCSQLType_String },
+	{ "varchar", k_EGCSQLType_String },
+	{ "nchar", k_EGCSQLType_String },
+	{ "nvarchar", k_EGCSQLType_String },
+	{ "sysname", k_EGCSQLType_String },
+	{ "varbinary", k_EGCSQLType_Blob },
+	{ "image", k_EGCSQLType_Image },
+};
+static uint32 g_cSQLTypeMapping = Q_ARRAYSIZE( g_rSQLTypeMapping );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the EGCSQLType for the specified SQL type name (or Invalid 
+//			for unsupported types.)
+//-----------------------------------------------------------------------------
+EGCSQLType ETypeFromMSSQLDataType( const char *pchType )
+{
+	for( uint32 unMapping = 0; unMapping < g_cSQLTypeMapping; unMapping++ )
+	{
+		if( !Q_stricmp( pchType, g_rSQLTypeMapping[ unMapping ].m_pchTypeName ) )
+			return g_rSQLTypeMapping[ unMapping ].m_eType;
+	}
+	return k_EGCSQLTypeInvalid;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Prepares the type map for use in schema upgrades
+//-----------------------------------------------------------------------------
+bool CJobUpdateSchema::YieldingBuildTypeMap( ESchemaCatalog eSchemaCatalog )
+{
+	CSQLAccess sqlAccess( eSchemaCatalog );
+	if( !sqlAccess.BYieldingExecute( FILE_AND_LINE, "select name, system_type_id from sys.types" ) )
+		return false;
+
+	FOR_EACH_SQL_RESULT( sqlAccess, 0, typeRecord )
+	{
+		CFmtStr1024 sTypeName;
+		byte nTypeID;
+		DbgVerify( typeRecord.BGetStringValue( 0, &sTypeName ) );
+		DbgVerify( typeRecord.BGetByteValue( 1, &nTypeID ) );
+
+		EGCSQLType eType = ETypeFromMSSQLDataType( sTypeName );
+		if( eType != k_EGCSQLTypeInvalid )
+			m_mapSQLTypeToEType.Insert( nTypeID, eType );
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the EGCSQLType for the specified type ID out of the database
+//-----------------------------------------------------------------------------
+EGCSQLType CJobUpdateSchema::GetEGCSQLTypeForMSSQLType( int nType )
+{
+	int nIndex = m_mapSQLTypeToEType.Find( nType );
+	if( m_mapSQLTypeToEType.IsValidIndex( nIndex ) )
+		return m_mapSQLTypeToEType[ nIndex ];
+	else
+		return k_EGCSQLTypeInvalid;
+}
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/sqlaccess.cpp b/gcsdk/sqlaccess/sqlaccess.cpp
new file mode 100644
index 0000000..130a446
--- /dev/null
+++ b/gcsdk/sqlaccess/sqlaccess.cpp
@@ -0,0 +1,953 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Provides access to SQL at a high level
+//
+//=============================================================================
+
+#include "stdafx.h"
+#include "gcsdk/sqlaccess/sqlaccess.h"
+#include "gcsdk/gcsqlquery.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+template< typename LISTENER_FUNC >
+static void RunAndClearListenerList( std::vector< LISTENER_FUNC > &vecListeners )
+{
+	// Let us not underestimate the ability of random listeners to re-enter everything.
+	std::vector< LISTENER_FUNC > listenerCopy;
+	listenerCopy.swap( vecListeners );
+	vecListeners.clear();
+
+	// Why would you consider such a thing
+	DO_NOT_YIELD_THIS_SCOPE();
+
+	for ( const auto &listener : listenerCopy )
+	{
+		listener();
+	}
+}
+
+
+namespace GCSDK
+{
+//------------------------------------------------------------------------------------
+// Purpose: Constructor
+//------------------------------------------------------------------------------------
+CSQLAccess::CSQLAccess( ESchemaCatalog eSchemaCatalog )
+	: m_eSchemaCatalog( eSchemaCatalog)
+	, m_pCurrentQuery( NULL )
+	, m_bInTransaction( false )
+{
+	m_pQueryGroup = CGCSQLQueryGroup::Alloc();
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Destructor
+//------------------------------------------------------------------------------------
+CSQLAccess::~CSQLAccess( )
+{
+	SAFE_RELEASE( m_pQueryGroup );
+	Assert( !m_pCurrentQuery );
+	SAFE_DELETE( m_pCurrentQuery );
+	AssertMsg( !m_bInTransaction, "GCSDK::CSQLAccess object being destroyed with a transaction pending. Use BCommitTransaction or RollbackTransaction to match your BBeginTransaction call." );
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Perform a query 
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BYieldingExecute( const char *pchName, const char *pchSQLCommand, uint32 *pcRowsAffected, bool bSpewOnError )
+{
+	if ( NULL == pchName )
+	{
+		pchName = pchSQLCommand;
+	}
+
+	bool bStandalone = !BInTransaction();
+	if( bStandalone )
+	{
+		BBeginTransaction( pchName );
+	}
+
+	CurrentQuery()->SetCommand( pchSQLCommand );
+	m_pQueryGroup->AddQuery( m_pCurrentQuery );
+	m_pCurrentQuery = NULL;
+
+	bool bSuccess = true;
+	if( bStandalone )
+	{
+		bSuccess = BCommitTransaction();
+		if( bSuccess && pcRowsAffected )
+		{
+			*pcRowsAffected = m_pQueryGroup->GetResults()->GetRowsAffected( 0 );
+		}
+	}
+	return bSuccess;
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Starts a transaction 
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BBeginTransaction( const char *pchName )
+{
+	Assert( !m_bInTransaction );
+	if( m_bInTransaction )
+		return false;
+	m_pQueryGroup->Clear();
+	m_pQueryGroup->SetName( pchName );
+	m_bInTransaction = true;
+	return true;
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Returns the string last passed to BBeginTransaction
+//------------------------------------------------------------------------------------
+const char *CSQLAccess::PchTransactionName( ) const
+{
+	return m_pQueryGroup->PchName();
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Commits a transaction to the database
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BCommitTransaction( bool bAllowEmpty )
+{
+	Assert( BInTransaction() );
+	if( !BInTransaction() )
+		return false;
+
+	if( !m_pCurrentQuery && !m_pQueryGroup->GetStatementCount() )
+	{
+		if( bAllowEmpty )
+		{
+			// No-op success
+			m_bInTransaction = false;
+			RunListeners_Commit();
+			return true;
+		}
+		else
+		{
+			AssertMsg1( false, "BCommitTransaction with empty transaction at %s", m_pQueryGroup->PchName() );
+			return false;
+		}
+	}
+
+	AssertMsg1( !m_pCurrentQuery, "Unexecuted query present in BCommitTransaction: %s", m_pCurrentQuery->PchCommand() );
+	if( m_pCurrentQuery )
+		return false;
+
+	m_bInTransaction = false;
+
+	if( !GJobCur().BYieldingRunQuery( m_pQueryGroup, m_eSchemaCatalog ) )
+	{
+		// Notify listeners that the transaction did not succeed
+		RunListeners_Rollback();
+		return false;
+	}
+
+	// The transaction presumably did make the database, so we do not notify rollback listeners beyond here.
+	RunListeners_Commit();
+
+	if( !m_pQueryGroup->GetResults() )
+		return false;
+
+	return true;
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Rolls back a transaction and clears any queries
+//------------------------------------------------------------------------------------
+void CSQLAccess::RollbackTransaction()
+{
+	bool bWasTransaction = BInTransaction();
+
+	Assert( bWasTransaction );
+	SAFE_DELETE( m_pCurrentQuery );
+	m_bInTransaction = false;
+
+	if ( bWasTransaction )
+	{
+		RunListeners_Rollback();
+	}
+	else
+	{
+		m_vecCommitListeners.clear();
+		m_vecRollbackListeners.clear();
+	}
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Adds a listener to be called synchronously should the transaction successfully commit
+//------------------------------------------------------------------------------------
+void CSQLAccess::AddCommitListener( std::function<void (void)> &&listener )
+{
+	if ( !BInTransaction() )
+	{
+		AssertMsg( BInTransaction(), "Adding a listener to a non-transaction access, will never fire" );
+		return;
+	}
+
+	m_vecCommitListeners.push_back( std::move( listener ) );
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Adds a listener to be called synchronously should the transaction fail or explicitly rollback
+//------------------------------------------------------------------------------------
+void CSQLAccess::AddRollbackListener( std::function<void (void)> &&listener )
+{
+	if ( !BInTransaction() )
+	{
+		AssertMsg( BInTransaction(), "Adding a listener to a non-transaction access, will never fire" );
+		return;
+	}
+
+	m_vecRollbackListeners.push_back( std::move( listener ) );
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Notifies listeners of successful commit.
+//------------------------------------------------------------------------------------
+void CSQLAccess::RunListeners_Commit()
+{
+	RunAndClearListenerList( m_vecCommitListeners );
+	// Clear the unused set
+	m_vecRollbackListeners.clear();
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Notifies listeners of a implicitly or explicitly rolled back transactions and clears the listener list.
+//------------------------------------------------------------------------------------
+void CSQLAccess::RunListeners_Rollback()
+{
+	RunAndClearListenerList( m_vecRollbackListeners );
+	// Clear the unused set
+	m_vecCommitListeners.clear();
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Perform a query that returns a single string
+//------------------------------------------------------------------------------------
+CSQLAccess::EReadSingleResultResult CSQLAccess::BYieldingExecuteSingleResultDataInternal( const char *pchName, const char *pchSQLCommand, EGCSQLType eType, uint8 **ppubData, uint32 *punSize, uint32 *pcRowsAffected, bool bHasDefaultValue )
+{
+	AssertMsg( !BInTransaction(),  "BYieldingExecuteSingleResultData is not supported in a transaction" );
+	if( BInTransaction() )
+		return eReadSingle_Error;
+
+	bool bRet = BYieldingExecute( pchName, pchSQLCommand, pcRowsAffected );
+	if ( !bRet )
+		return eReadSingle_Error;
+
+	if( m_pQueryGroup->GetResults()->GetResultSetCount() != 1 )
+	{
+		AssertMsg1( false, "Expected single result set, found %d", m_pQueryGroup->GetResults()->GetResultSetCount() );
+		return eReadSingle_Error;
+	}
+
+	IGCSQLResultSet *pResultSet = m_pQueryGroup->GetResults()->GetResultSet( 0 );
+
+	// If we have a default value, getting back zero rows is acceptable.
+	if( pResultSet->GetRowCount() == 0 && bHasDefaultValue )
+	{
+		return eReadSingle_UseDefault;
+	}
+
+	// If we either have more than one row or no default value specified, that's an error.
+	if( pResultSet->GetRowCount() != 1 )
+	{
+		AssertMsg1( false, "Expected single result, found %d", pResultSet->GetRowCount() );
+		return eReadSingle_Error;
+	}
+
+	if( pResultSet->GetColumnCount() != 1 )
+	{
+		AssertMsg1( false, "Expected single column, found %d", pResultSet->GetColumnCount() );
+		return eReadSingle_Error;
+	}
+	if( pResultSet->GetColumnType( 0 ) != eType )
+	{
+		AssertMsg2( false, "Expected column of type %s, found %s", PchNameFromEGCSQLType( eType ), PchNameFromEGCSQLType( pResultSet->GetColumnType( 0 ) ) );
+		return eReadSingle_Error;
+	}
+
+	return pResultSet->GetData( 0, 0, ppubData, punSize )
+		 ? eReadSingle_ResultFound
+		 : eReadSingle_Error;
+}
+
+
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Perform a query that returns a single string
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BYieldingExecuteString( const char *pchName, const char *pchSQLCommand, CFmtStr1024 *psResult, uint32 *pcRowsAffected )
+{
+	uint8 *pubData;
+	uint32 cubData;
+	if( CSQLAccess::BYieldingExecuteSingleResultDataInternal( pchName, pchSQLCommand, k_EGCSQLType_String, &pubData, &cubData, pcRowsAffected, false ) != eReadSingle_ResultFound )
+		return false;
+
+	*psResult = (char *)pubData;
+
+	return true;
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Perform a query that returns a single int
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BYieldingExecuteScalarInt( const char *pchName, const char *pchSQLCommand, int *pnResult, uint32 *pcRowsAffected )
+{
+	return BYieldingExecuteSingleResult<int32, uint32>( pchName, pchSQLCommand, k_EGCSQLType_int32, pnResult, pcRowsAffected );
+}
+
+bool CSQLAccess::BYieldingExecuteScalarIntWithDefault( const char *pchName, const char *pchSQLCommand, int *pnResult, int iDefaultValue, uint32 *pcRowsAffected )
+{
+	return BYieldingExecuteSingleResultWithDefault<int32, uint32>( pchName, pchSQLCommand, k_EGCSQLType_int32, pnResult, iDefaultValue, pcRowsAffected );
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: Perform a query that returns a single uint32
+//------------------------------------------------------------------------------------
+bool CSQLAccess::BYieldingExecuteScalarUint32( const char *pchName, const char *pchSQLCommand, uint32 *punResult, uint32 *pcRowsAffected )
+{
+	return BYieldingExecuteSingleResult<uint32, uint32>( pchName, pchSQLCommand, k_EGCSQLType_int32, punResult, pcRowsAffected );
+}
+
+bool CSQLAccess::BYieldingExecuteScalarUint32WithDefault( const char *pchName, const char *pchSQLCommand, uint32 *punResult, uint32 unDefaultValue, uint32 *pcRowsAffected )
+{
+	return BYieldingExecuteSingleResultWithDefault<uint32, uint32>( pchName, pchSQLCommand, k_EGCSQLType_int32, punResult, unDefaultValue, pcRowsAffected );
+}
+
+//------------------------------------------------------------------------------------
+// Purpose: A bunch of pass throughs to the query itself
+//------------------------------------------------------------------------------------
+void CSQLAccess::AddBindParam( const char *pchValue )
+{
+	CurrentQuery()->AddBindParam( pchValue );
+}
+
+void CSQLAccess::AddBindParam( const int16 nValue )
+{
+	CurrentQuery()->AddBindParam( nValue );
+}
+
+void CSQLAccess::AddBindParam( const uint16 uValue )
+{
+	CurrentQuery()->AddBindParam( uValue );
+}
+
+void CSQLAccess::AddBindParam( const int32 nValue )
+{
+	CurrentQuery()->AddBindParam( nValue );
+}
+
+void CSQLAccess::AddBindParam( const uint32 uValue )
+{
+	CurrentQuery()->AddBindParam( uValue );
+}
+
+void CSQLAccess::AddBindParam( const uint64 ulValue )
+{
+	CurrentQuery()->AddBindParam( ulValue );
+}
+
+void CSQLAccess::AddBindParam( const uint8 *ubValue, const int cubValue )
+{
+	CurrentQuery()->AddBindParam( ubValue, cubValue );
+}
+
+void CSQLAccess::AddBindParam( const float fValue )
+{
+	CurrentQuery()->AddBindParam( fValue );
+}
+
+void CSQLAccess::AddBindParam( const double dValue )
+{
+	CurrentQuery()->AddBindParam( dValue );
+}
+
+void CSQLAccess::AddBindParamRaw( EGCSQLType eType, const byte *pubData, uint32 cubData )
+{
+	CurrentQuery()->AddBindParamRaw( eType, pubData, cubData );
+}
+
+void CSQLAccess::ClearParams()
+{
+	if( m_pCurrentQuery )
+	{
+		delete m_pCurrentQuery;
+		m_pCurrentQuery = NULL;
+	}
+}
+
+
+IGCSQLResultSetList *CSQLAccess::GetResults()
+{
+	return m_pQueryGroup->GetResults();
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Returns the number of result sets
+//------------------------------------------------------------------------------------
+uint32 CSQLAccess::GetResultSetCount()
+{
+	if( m_pQueryGroup->GetResults() )
+		return m_pQueryGroup->GetResults()->GetResultSetCount();
+	else
+		return 0;
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Returns the number of rows in a result set
+//------------------------------------------------------------------------------------
+uint32 CSQLAccess::GetResultSetRowCount( uint32 unResultSet )
+{
+	if( m_pQueryGroup->GetResults() && unResultSet < m_pQueryGroup->GetResults()->GetResultSetCount() )
+		return m_pQueryGroup->GetResults()->GetResultSet( unResultSet )->GetRowCount();
+	else
+		return 0;
+}
+
+
+//------------------------------------------------------------------------------------
+// Purpose: Returns a CSQLRecord object that represents a row in a result set
+//------------------------------------------------------------------------------------
+CSQLRecord CSQLAccess::GetResultRecord( uint32 unResultSet, uint32 unRow )
+{
+	if( m_pQueryGroup->GetResults() && unResultSet < m_pQueryGroup->GetResults()->GetResultSetCount() )
+	{
+		IGCSQLResultSet *pResultSet = m_pQueryGroup->GetResults()->GetResultSet( unResultSet );
+		if( unRow < pResultSet->GetRowCount() )
+			return CSQLRecord( unRow, pResultSet );
+	}
+	return CSQLRecord(); // if there was a problem return an empty record
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Inserts a new record into the DS
+// Input:	pRecordBase - record to insert
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingInsertRecord( const CRecordBase *pRecordBase )
+{
+	ClearParams();
+
+	const CRecordInfo *pRecordInfo = pRecordBase->GetPSchema()->GetRecordInfo();
+	int cColumns = pRecordInfo->GetNumColumns();
+	for ( int nColumn = 0; nColumn < cColumns; nColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( nColumn );
+		if ( !columnInfo.BIsInsertable() )
+			continue;
+
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( pRecordBase->BGetField( nColumn, &pubData, &cubData ) );
+		
+		CurrentQuery()->AddBindParamRaw( columnInfo.GetType(), pubData, cubData );
+	}
+
+	uint32 nRows;
+	const char *pchStatement = pRecordBase->GetPSchema()->GetInsertStatementText();
+
+	bool bRet = BYieldingExecute( pchStatement, pchStatement, &nRows );
+	return ( nRows == 1 || BInTransaction() ) && bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Inserts a new record into the DS if such row doesn't exist
+// Input:	pRecordBase - record to insert
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingInsertWhenNotMatchedOnPK( CRecordBase *pRecordBase )
+{
+	ClearParams();
+
+	const CRecordInfo *pRecordInfo = pRecordBase->GetPSchema()->GetRecordInfo();
+	int cColumns = pRecordInfo->GetNumColumns();
+	for ( int nColumn = 0; nColumn < cColumns; nColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( nColumn );
+		if ( !columnInfo.BIsInsertable() )
+		{
+			Assert( columnInfo.BIsInsertable() );
+			return false;
+		}
+
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( pRecordBase->BGetField( nColumn, &pubData, &cubData ) );
+
+		CurrentQuery()->AddBindParamRaw( columnInfo.GetType(), pubData, cubData );
+	}
+
+	uint32 nRows;
+	const char *pchStatement = pRecordBase->GetPSchema()->GetMergeStatementTextOnPKWhenNotMatchedInsert();
+
+	bool bRet = BYieldingExecute( pchStatement, pchStatement, &nRows );
+	return ( nRows == 1 || nRows == 0 || BInTransaction() ) && bRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Inserts a new record into the DS if such row doesn't exist
+//			updates an existing row if such row is matched by PK
+// Input:	pRecordBase - record to insert
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingInsertOrUpdateOnPK( CRecordBase *pRecordBase )
+{
+	ClearParams();
+
+	const CRecordInfo *pRecordInfo = pRecordBase->GetPSchema()->GetRecordInfo();
+	int cColumns = pRecordInfo->GetNumColumns();
+	for ( int nColumn = 0; nColumn < cColumns; nColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( nColumn );
+		if ( !columnInfo.BIsInsertable() )
+		{
+			Assert( columnInfo.BIsInsertable() );
+			return false;
+		}
+
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( pRecordBase->BGetField( nColumn, &pubData, &cubData ) );
+
+		CurrentQuery()->AddBindParamRaw( columnInfo.GetType(), pubData, cubData );
+	}
+
+	uint32 nRows;
+	const char *pchStatement = pRecordBase->GetPSchema()->GetMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert();
+
+	bool bRet = BYieldingExecute( pchStatement, pchStatement, &nRows );
+	return ( nRows == 1 || BInTransaction() ) && bRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Inserts a new record into the DB and reads non-insertable fields back
+//			into the record.
+// Input:	pRecordBase - record to insert
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingInsertWithIdentity( CRecordBase* pRecordBase ) 
+{
+	AssertMsg( !BInTransaction(),  "BYieldingInsertWithIdentity is not supported in a transaction" );
+	if( BInTransaction() )
+		return false;
+	ClearParams();
+
+	TSQLCmdStr sStatement;
+	CUtlVector<int> vecOutputFields;
+	CRecordInfo *pRecordInfo = pRecordBase->GetPSchema()->GetRecordInfo();
+	BuildInsertAndReadStatementText( &sStatement, &vecOutputFields, pRecordInfo );
+
+	AssertMsg( vecOutputFields.Count() > 0, "BYieldingInsertAndReadRecord called for a record type with no non-insertable columns" );
+	if ( vecOutputFields.Count() == 0 )
+		return false;
+
+	int cColumns = pRecordInfo->GetNumColumns();
+	for ( int nColumn = 0; nColumn < cColumns; nColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( nColumn );
+		if ( !columnInfo.BIsInsertable() )
+		{
+			continue;
+		}
+
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( pRecordBase->BGetField( nColumn, &pubData, &cubData ) );
+
+		CurrentQuery()->AddBindParamRaw( columnInfo.GetType(), pubData, cubData );
+	}
+
+	bool bRet = BYieldingExecute( sStatement, sStatement );
+	if( !bRet )
+		return false;
+
+	Assert( 1 == GetResultSetCount() );
+	if ( 1 != GetResultSetCount() )
+		return false;
+
+	IGCSQLResultSet *pResultSet = m_pQueryGroup->GetResults()->GetResultSet( 0 );
+	Assert( 1 == pResultSet->GetRowCount() );
+	if ( 1 != pResultSet->GetRowCount() )
+		return false;
+
+	Assert( (uint32)vecOutputFields.Count() == pResultSet->GetColumnCount() );
+	if ( (uint32)vecOutputFields.Count() != pResultSet->GetColumnCount() )
+		return false;
+
+	for( uint32 nColumn = 0; nColumn < pResultSet->GetColumnCount(); nColumn++ )
+	{
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( pResultSet->GetData( 0, nColumn, &pubData, &cubData ) );
+
+		int nSchColumn = vecOutputFields[nColumn];
+		Assert( pResultSet->GetColumnType( nColumn ) == pRecordInfo->GetColumnInfo( nSchColumn ).GetType() );
+		DbgVerify( pRecordBase->BSetField( nSchColumn, pubData, cubData ) );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Reads a list of records from the DB according to the specified where
+//			clause
+// Input:	pRecordBase - record to read
+//			readSet - The set of columns to read
+//			whereSet - The set of columns to query on
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+EResult CSQLAccess::YieldingReadRecordWithWhereColumns( CRecordBase *pRecord, const CColumnSet & readSet, const CColumnSet & whereSet, const char* pchOrderClause )
+{
+	AssertMsg( !BInTransaction(), "BYieldingReadRecordWithWhereColumns is not supported in a transaction" );
+	if( BInTransaction() )
+		return k_EResultInvalidState;
+
+	//if there is an order by clause, only take the top one, if there isn't, then validate that we have a single instance
+	const char* pszTopClause = ( pchOrderClause ) ? "TOP (1)" : "TOP (2)";
+
+	TSQLCmdStr sStatement;
+	BuildSelectStatementText( &sStatement, readSet, pszTopClause );
+
+	// if we actually have some columns for the where clause,
+	// append a where clause.
+	if( whereSet.GetColumnCount() )
+	{
+		sStatement.Append( " WHERE " );
+		AppendWhereClauseText( &sStatement, whereSet );
+		AddRecordParameters( *pRecord, whereSet );
+	}
+	//append the order by if they added one
+	if( pchOrderClause )
+	{
+		sStatement.Append( " ORDER BY " );
+		sStatement.Append( pchOrderClause );
+	}
+
+	Assert(!readSet.IsEmpty() );
+	if( !BYieldingExecute( sStatement, sStatement ) )
+		return k_EResultFail;
+
+	if ( GetResultSetCount() != 1 )
+	{
+		AssertMsg( GetResultSetCount() == 1, "Unexpected number of result sets returned from select statement" );
+		return k_EResultFail;
+	}
+
+	// make sure the types are the same
+	IGCSQLResultSet *pResultSet = m_pQueryGroup->GetResults()->GetResultSet( 0 );
+	if ( pResultSet->GetRowCount() == 0 )
+		return k_EResultNoMatch;
+
+	//note that since we only take the top one when there is an order by clause, we don't need to handle that case down here, only if top 2 is selected
+	if( pResultSet->GetRowCount() != 1 )
+	{
+		// Make sure we aren't failing because there are multiple matching records.
+		// That is probably a misuse of the API or some unexpected condition.
+		AssertMsg1( false, "BYieldingReadRecordWithWhereColumns from %s failing because multiple records match WHERE clause", readSet.GetRecordInfo()->GetName() );
+		return k_EResultLimitExceeded;
+	}
+	FOR_EACH_COLUMN_IN_SET( readSet, nColumnIndex )
+	{
+		EGCSQLType eRecordType = readSet.GetColumnInfo( nColumnIndex ).GetType();
+		EGCSQLType eResultType = pResultSet->GetColumnType( nColumnIndex );
+
+		AssertMsg2( eResultType == eRecordType, "Column %d type mismatch in %s", nColumnIndex, readSet.GetRecordInfo()->GetName() );
+		if( eRecordType != eResultType )
+			return k_EResultInvalidParam;
+	}
+
+	CSQLRecord sqlRecord = GetResultRecord( 0, 0 );
+
+	FOR_EACH_COLUMN_IN_SET( readSet, nColumnIndex )
+	{
+		uint8 *pubData;
+		uint32 cubData;
+
+		DbgVerify( sqlRecord.BGetColumnData( nColumnIndex, &pubData, (int*)&cubData ) );
+		DbgVerify( pRecord->BSetField( readSet.GetColumn( nColumnIndex), pubData, cubData ) );
+	}
+
+	return k_EResultOK;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates a record in the DB
+// Input:	record - data source for columns to match against (whereColumns) and
+//					 columns to assign (updateColumns)
+//			whereColumns - columns to match against
+//			updateColumns - columns to update
+// Output:	true if successful, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingUpdateRecord( const CRecordBase & record, const CColumnSet & whereColumns, const CColumnSet & updateColumns, const CSQLOutputParams *pOptionalOutputParams /* = NULL */ )
+{
+	return BYieldingUpdateRecords( record, whereColumns, record, updateColumns, pOptionalOutputParams );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingUpdateRecords( const CRecordBase & whereRecord, const CColumnSet & whereColumns, const CRecordBase & updateRecord, const CColumnSet & updateColumns, const CSQLOutputParams *pOptionalOutputParams /* = NULL */ )
+{
+	ClearParams();
+
+	Assert( whereColumns.GetRecordInfo() == updateColumns.GetRecordInfo() );
+	if ( whereColumns.GetRecordInfo() != updateColumns.GetRecordInfo() )
+		return false;
+	Assert( whereColumns.GetRecordInfo() == whereRecord.GetPSchema()->GetRecordInfo() );
+	if ( whereColumns.GetRecordInfo() != whereRecord.GetPSchema()->GetRecordInfo() )
+		return false;
+	Assert( whereColumns.GetRecordInfo() == updateRecord.GetPSchema()->GetRecordInfo() );
+	if ( whereColumns.GetRecordInfo() != updateRecord.GetPSchema()->GetRecordInfo() )
+		return false;
+
+	AssertMsg( !updateColumns.IsEmpty(), "Someone is calling BYieldingUpdateRecord with no columns to update." );
+	if ( updateColumns.IsEmpty() )
+		return false;
+
+	// add the columns we're updating as bound params
+	TSQLCmdStr sStatement;
+	BuildUpdateStatementText( &sStatement, updateColumns );
+
+	AddRecordParameters( updateRecord, updateColumns );
+
+	// did the users specify an OUTPUT block?
+	if ( pOptionalOutputParams )
+	{
+		TSQLCmdStr sOutput;
+		BuildOutputClauseText( &sOutput, pOptionalOutputParams->GetColumnSet() );
+		sStatement.Append( sOutput );
+
+		AddRecordParameters( pOptionalOutputParams->GetRecord(), pOptionalOutputParams->GetColumnSet() );
+	}
+
+	if ( !whereColumns.IsEmpty() )
+	{
+		sStatement.Append( " WHERE " );
+		AppendWhereClauseText( &sStatement, whereColumns );
+	
+		// add the columns we're querying on as bound params
+		AddRecordParameters( whereRecord, whereColumns );
+	}
+
+	return BYieldingExecute( sStatement, sStatement );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deletes this record's row in the table
+// Input:	record - record to delete
+//			whereColumns - columns to use when searching for this record
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingDeleteRecords( const CRecordBase & record, const CColumnSet & whereColumns )
+{
+	Assert( whereColumns.GetRecordInfo() == record.GetPSchema()->GetRecordInfo() );
+	if ( whereColumns.GetRecordInfo() != record.GetPSchema()->GetRecordInfo() )
+		return false;
+
+	ClearParams();
+	AddRecordParameters( record, whereColumns );
+
+	TSQLCmdStr sStatement;
+	BuildDeleteStatementText( &sStatement, record.GetPRecordInfo() );
+	sStatement.Append( " WHERE " );
+	AppendWhereClauseText( &sStatement, whereColumns );
+
+	uint32 unRowsAffected;
+	if( !BYieldingExecute( sStatement, sStatement, &unRowsAffected ) )
+		return false;
+
+	return unRowsAffected > 0 || BInTransaction();
+}
+
+//--------------------------------------------------------------------------------------------------------------------------------
+// CSQLUpdateOrInsert
+//--------------------------------------------------------------------------------------------------------------------------------
+
+CSQLUpdateOrInsert::CSQLUpdateOrInsert( const char* pszName, int nTable, const CColumnSet & whereColumns, const CColumnSet & updateColumns, const char* pszWhereClause, const char* pszUpdateClause )
+{
+	const CRecordInfo* pRecordInfo = GSchemaFull().GetSchema( nTable ).GetRecordInfo();
+
+	//how many columns do we have 
+	const int nNumColumns = pRecordInfo->GetNumColumns();
+
+	TSQLCmdStr sStatement;
+	sStatement = "MERGE INTO ";
+	sStatement.Append( GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ) );
+	sStatement.Append( '.' );
+	sStatement.Append( pRecordInfo->GetName() );
+	sStatement.Append( " WITH(HOLDLOCK) AS D USING(VALUES(" );
+	sStatement.AppendFormat( "%.*s", GetInsertArgStringChars( nNumColumns ), GetInsertArgString() );
+	sStatement.Append( "))AS S(" );
+
+	//add each column that we are adding the values for, along with the parameter from the structure
+	for( int nCurrColumn = 0; nCurrColumn < nNumColumns; nCurrColumn++ )
+	{
+		const CColumnInfo& colInfo = pRecordInfo->GetColumnInfo( nCurrColumn );
+		if( nCurrColumn != 0 )
+			sStatement.Append( ',' );
+		sStatement.Append( colInfo.GetName() );
+	}
+
+	//our where clause
+	sStatement.Append( ")ON " );
+
+	if( pszWhereClause )
+	{
+		sStatement.Append( pszWhereClause );
+	}
+	else
+	{
+		FOR_EACH_COLUMN_IN_SET( whereColumns, nCurrColumn )
+		{
+			const char* pszColName = pRecordInfo->GetColumnInfo( whereColumns.GetColumn( nCurrColumn ) ).GetName();
+			if( nCurrColumn > 0 )
+				sStatement.Append( " AND " );
+			sStatement.AppendFormat( "D.%s=S.%s", pszColName, pszColName );
+		}
+	}
+
+	//our update clause (if they have provided fields that they want to update)
+	if( pszUpdateClause || !updateColumns.IsEmpty() )
+	{
+		sStatement.Append( " WHEN MATCHED THEN UPDATE SET " );
+		if( pszUpdateClause )
+		{
+			sStatement.Append( pszUpdateClause );
+		}
+		else
+		{
+			FOR_EACH_COLUMN_IN_SET( updateColumns, nCurrColumn )
+			{
+				const char* pszColName = pRecordInfo->GetColumnInfo( updateColumns.GetColumn( nCurrColumn ) ).GetName();
+				if( nCurrColumn > 0 )
+					sStatement.Append( ',' );
+				sStatement.AppendFormat( "%s=S.%s", pszColName, pszColName );
+			}
+		}
+	}
+
+	//our insert clause
+	sStatement.Append( " WHEN NOT MATCHED THEN INSERT(" );
+	bool bFirstColumn = true;
+	for( int nCurrColumn = 0; nCurrColumn < nNumColumns; nCurrColumn++ )
+	{
+		const CColumnInfo& colInfo = pRecordInfo->GetColumnInfo( nCurrColumn );
+		if( !colInfo.BIsInsertable() )
+			continue;
+
+		if( !bFirstColumn )
+			sStatement.Append( ',' );
+		bFirstColumn = false;
+		sStatement.Append( colInfo.GetName() );
+	}
+
+	sStatement.Append( ")VALUES(" );
+	bFirstColumn = true;
+	for( int nCurrColumn = 0; nCurrColumn < nNumColumns; nCurrColumn++ )
+	{
+		const CColumnInfo& colInfo = pRecordInfo->GetColumnInfo( nCurrColumn );
+		if( !colInfo.BIsInsertable() )
+			continue;
+
+		if( !bFirstColumn )
+			sStatement.Append( ',' );
+		bFirstColumn = false;
+		sStatement.AppendFormat( "S.%s", colInfo.GetName() );
+	}
+	sStatement.Append( ");" );
+
+	//save our results so we can execute it in the future
+	m_nTable = nTable;
+	m_sName = pszName;
+	m_sQuery = sStatement;
+}
+
+bool CSQLUpdateOrInsert::BYieldingExecute( CSQLAccess& sqlAccess, const CRecordBase& record, uint32 *out_punRowsAffected /* = NULL */ ) const
+{
+	AssertMsg2( record.GetITable() == m_nTable, "Error: Merge was compiled for table %s, but was attempted to be executed against %s", GSchemaFull().GetSchema( m_nTable ).GetRecordInfo()->GetName(), record.GetPRecordInfo()->GetName() );
+
+	const CRecordInfo* pRecordInfo = record.GetPRecordInfo();
+	//how many columns do we have 
+	const int nNumColumns = pRecordInfo->GetNumColumns();
+
+	sqlAccess.ClearParams();
+	for( int nCurrColumn = 0; nCurrColumn < nNumColumns; nCurrColumn++ )
+	{
+		const CColumnInfo& colInfo = pRecordInfo->GetColumnInfo( nCurrColumn );
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( record.BGetField( nCurrColumn, &pubData, &cubData ) );
+		sqlAccess.AddBindParamRaw( colInfo.GetType(), pubData, cubData );
+	}
+
+	return sqlAccess.BYieldingExecute( m_sName, m_sQuery, out_punRowsAffected );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds bind parameters to the list based on a set of fields in a record
+// Input:	record - record to insert
+//			columnSet - The set of columns to add as params
+//-----------------------------------------------------------------------------
+void CSQLAccess::AddRecordParameters( const CRecordBase &record, const CColumnSet & columnSet )
+{
+	Assert( record.GetPSchema()->GetRecordInfo() == columnSet.GetRecordInfo() );
+	if ( record.GetPSchema()->GetRecordInfo() != columnSet.GetRecordInfo() )
+		return;
+
+	FOR_EACH_COLUMN_IN_SET( columnSet, nColumnIndex )
+	{
+		const CColumnInfo &columnInfo = columnSet.GetColumnInfo( nColumnIndex );
+		uint8 *pubData;
+		uint32 cubData;
+		DbgVerify( record.BGetField( columnSet.GetColumn( nColumnIndex ), &pubData, &cubData ) );
+		EGCSQLType eType = columnInfo.GetType();
+		CurrentQuery()->AddBindParamRaw( eType, pubData, cubData );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Deletes all records from a table
+// Input:	iTable - table to wipe
+// Output:	true if the operation was successful
+// Note:	PERFORMANCE WARNING: this is slow on big tables, not intended for use
+//				in production
+//-----------------------------------------------------------------------------
+bool CSQLAccess::BYieldingWipeTable( int iTable )
+{
+	// make a wipe operation
+	CRecordInfo *pRecordInfo = GSchemaFull().GetSchema( iTable ).GetRecordInfo();
+
+	CUtlString buf;
+	buf.Format( "DELETE FROM %s", pRecordInfo->GetName() );
+	return BYieldingExecute( buf.String(), buf.String() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the current query to add stuff to, creating it if there isn't
+//			already a current query
+//-----------------------------------------------------------------------------
+CGCSQLQuery *CSQLAccess::CurrentQuery()
+{
+	if( m_pCurrentQuery )
+		return m_pCurrentQuery;
+
+	m_pCurrentQuery = new CGCSQLQuery();
+	return m_pCurrentQuery;
+}
+
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/sqlrecord.cpp b/gcsdk/sqlaccess/sqlrecord.cpp
new file mode 100644
index 0000000..5b285b4
--- /dev/null
+++ b/gcsdk/sqlaccess/sqlrecord.cpp
@@ -0,0 +1,538 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $NoKeywords: $
+//=============================================================================
+
+
+#include "stdafx.h"
+
+//#include "sqlaccess.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+namespace GCSDK
+{
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CSQLRecord::CSQLRecord( uint32 unRow, IGCSQLResultSet *pResultSet )
+{
+	Init( unRow, pResultSet );
+}
+CSQLRecord::CSQLRecord()
+: m_pResultSet( NULL ), m_unRow( 0 )
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CSQLRecord::~CSQLRecord()
+{
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Initializes a blank record
+// Input:	iTable - table that this record will belong to
+//-----------------------------------------------------------------------------
+void CSQLRecord::Init( uint32 unRow, IGCSQLResultSet *pResultSet )
+{
+	if( unRow >= pResultSet->GetRowCount() )
+	{
+		m_pResultSet = NULL;
+		m_unRow = 0;
+	}
+	else
+	{
+		m_pResultSet = pResultSet;
+		m_unRow = unRow;
+	}
+}	
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets data for a field in this record
+// Input:	unColumn - field to get
+//			pubField - pointer to get filled in with pointer to data
+//			cubField - pointer to get filled in with size of data
+// Output:	true if successful, false if data not present
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetColumnData( uint32 unColumn, uint8 **ppubField, int *pcubField )
+{
+	size_t sz;
+	bool bRet = BGetColumnData( unColumn, ppubField, &sz );
+	*pcubField = static_cast< int >( sz );
+	return bRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets data for a field in this record
+// Input:	unColumn - field to get
+//			pubField - pointer to get filled in with pointer to data
+//			cubField - pointer to get filled in with size of data
+// Output:	true if successful, false if data not present
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetColumnData( uint32 unColumn, uint8 **ppubField, size_t *pcubField )
+{
+	Assert( ppubField );
+	Assert( pcubField );
+	*ppubField = NULL;
+	*pcubField = 0;
+
+	Assert( m_pResultSet );
+
+	if ( !BValidateColumnIndex( unColumn ) )
+		return false;
+
+	*pcubField = 0;
+	return m_pResultSet->GetData( m_unRow, unColumn, ppubField, (uint32*)pcubField );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets string data for a field in this record
+// Input:	unColumn - field to get
+//			ppchVal - pointer to pointer to fill in to string data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetStringValue( uint32 unColumn, const char **ppchVal )
+{
+	Assert( ppchVal );
+	*ppchVal = NULL;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;
+	Assert( k_EGCSQLType_String == m_pResultSet->GetColumnType( unColumn ) );
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+		*ppchVal = (const char *) pubData;
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets string data for a field in this record
+// Input:	unColumn - field to get
+//			ppchVal - pointer to pointer to fill in to string data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetStringValue( uint32 unColumn, CFmtStr1024 *psVal )
+{
+	Assert( psVal );
+	*psVal = "";
+
+	uint8 *pubData = NULL;
+	int cubData = 0;
+	Assert( k_EGCSQLType_String == m_pResultSet->GetColumnType( unColumn ) );
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+		*psVal = (const char *) pubData;
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets int data for a field in this record
+// Input:	unColumn - field to get
+//			pnVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetIntValue( uint32 unColumn, int *pnVal )
+{
+	Assert( pnVal );
+	*pnVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		switch( m_pResultSet->GetColumnType( unColumn ) )
+		{
+			case k_EGCSQLType_int64:
+			{
+				int64 ul = *((int64 *)pubData);
+				if ( ul >= LONG_MIN && ul <= LONG_MAX )
+				{
+					*pnVal = (int)ul;
+					return true;
+				}
+				else
+				{
+					AssertMsg1(false, "GetIntValue tried to catch %lld in an int, which is too small", ul );
+					return false;
+				}
+			}
+			break;
+
+			case k_EGCSQLType_int32:
+				*pnVal = *((int32 *)pubData);
+				return true;
+
+			case k_EGCSQLType_int16:
+				*pnVal = *((int16 *)pubData);
+				return true;
+
+			case k_EGCSQLType_int8:
+				*pnVal = *((int8 *)pubData);
+				return true;
+
+			default:
+				AssertMsg1(false, "GetIntValue tried to catch a %s, which is the wrong type", PchNameFromEGCSQLType( m_pResultSet->GetColumnType( unColumn ) ) );
+				return false;
+		}
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets float data for a field in this record
+// Input:	unColumn - field to get
+//			pnVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetFloatValue( uint32 unColumn, float *pfVal )
+{
+	Assert( pfVal );
+	*pfVal = 0.0f;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_float == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg2( sizeof( float ) == cubData, "GetValue expected %llu bytes, found %d", (uint64)sizeof( float ), cubData );
+		if ( sizeof( float ) != cubData )
+			return false;
+		*pfVal =  *( (float *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets double data for a field in this record
+// Input:	unColumn - field to get
+//			pnVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetDoubleValue( uint32 unColumn, double *pdVal )
+{
+	Assert( pdVal );
+	*pdVal = 0.0f;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_double == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg2( sizeof( double ) == cubData, "GetValue expected %llu bytes, found %d", (uint64)sizeof( double ), cubData );
+		if ( sizeof( double ) != cubData )
+			return false;
+		*pdVal =  *( (double *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets int data for a field in this record
+// Input:	unColumn - field to get
+//			pVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetByteValue( uint32 unColumn, byte *pVal )
+{
+	Assert( pVal );
+	*pVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int8 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 1 == cubData, "GetValue expected 1 bytes, found %d", cubData );
+		if ( 1 != cubData )
+			return false;
+		*pVal =  *( (byte *) pubData );
+	}
+
+	return bRet;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets int data for a field in this record
+// Input:	unColumn - field to get
+//			pVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetBoolValue( uint32 unColumn, bool *pVal )
+{
+	int32 b;
+	if ( !BGetIntValue( unColumn, &b ) )
+		return false;
+
+	// convert to boolean
+	*pVal = ( b != 0 );
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets int16 data for a field in this record
+// Input:	unColumn - field to get
+//			pnVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetInt16Value( uint32 unColumn, int16 *pnVal )
+{
+	Assert( pnVal );
+	*pnVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int16 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 2 == cubData, "GetValue expected 2 bytes, found %d", cubData );
+		if ( 2 != cubData )
+			return false;
+		*pnVal = *( (int16 *) pubData );
+	}
+	return bRet;	
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets int64 data for a field in this record
+// Input:	unColumn - field to get
+//			puVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetInt64Value( uint32 unColumn, int64 *puVal )
+{
+	Assert( puVal );
+	*puVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int64 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 8 == cubData, "GetValue expected 8 bytes, found %d", cubData );
+		if ( 8 != cubData )
+			return false;
+		*puVal = *( (int64 *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets uint64 data for a field in this record
+// Input:	unColumn - field to get
+//			puVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetUint64Value( uint32 unColumn, uint64 *puVal )
+{
+	Assert( puVal );
+	*puVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int64 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 8 == cubData, "GetValue expected 8 bytes, found %d", cubData );
+		if ( 8 != cubData )
+			return false;
+		*puVal = *( (uint64 *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets uint32 data for a field in this record
+// Input:	unColumn - field to get
+//			puVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetUint32Value( uint32 unColumn, uint32 *puVal )
+{
+	Assert( puVal );
+	*puVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int32 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 4 == cubData, "GetValue expected 4 bytes, found %d", cubData );
+		if ( 4 != cubData )
+			return false;
+		*puVal = *( (uint32 *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets uint16 data for a field in this record
+// Input:	unColumn - field to get
+//			puVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetUint16Value( uint32 unColumn, uint16 *puVal )
+{
+	Assert( puVal );
+	*puVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int16 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 2 == cubData, "GetValue expected 2 bytes, found %d", cubData );
+		if ( 2 != cubData )
+			return false;
+		*puVal = *( (uint16 *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Gets uint8 data for a field in this record
+// Input:	unColumn - field to get
+//			puVal - pointer to fill in with data
+// Output:	true if successful, false if data not present or not of correct type
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BGetUint8Value( uint32 unColumn, uint8 *puVal )
+{
+	Assert( puVal );
+	*puVal = 0;
+
+	uint8 *pubData = NULL;
+	int cubData = 0;	
+	bool bRet = BGetColumnData( unColumn, &pubData, &cubData );
+	if ( bRet )
+	{
+		Assert( k_EGCSQLType_int8 == m_pResultSet->GetColumnType( unColumn ) );
+		AssertMsg1( 1 == cubData, "GetValue expected 1 byte, found %d", cubData );
+		if ( 1 != cubData )
+			return false;
+		*puVal = *( (uint8 *) pubData );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Validates column index
+// Input:	unColumn - field to validate
+// Output:	true if valid, false otherwise
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BValidateColumnIndex( uint32 unColumn )
+{
+	if (  unColumn >= m_pResultSet->GetColumnCount() )
+	{
+		AssertMsg2( false, "CSQLRecord::BValidateColumnIndex: invalid column index %d.  # columns: %d", unColumn,
+			m_pResultSet->GetColumnCount() );
+		return false;
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Advances the CSQLRecord to the next row 
+// Output:	returns false if this call would advance the record past the last row.
+//			And makes the record invalid.
+//-----------------------------------------------------------------------------
+bool CSQLRecord::NextRow()
+{
+	Assert( m_pResultSet );
+	m_unRow++;
+	
+	if( m_unRow >= m_pResultSet->GetRowCount() )
+		m_pResultSet = NULL;
+	return IsValid();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Render a field to a buffer
+// Input:	unColumn - field to render
+//			cchBuffer - size of render buffer
+//			pchBuffer - buffer to render into
+//-----------------------------------------------------------------------------
+void CSQLRecord::RenderField( uint32 unColumn, int cchBuffer, char *pchBuffer )
+{
+	Q_strncpy( pchBuffer, "", cchBuffer );
+
+	uint8 *pubData;
+	int cubData;
+	if ( !BGetColumnData( unColumn, &pubData, &cubData ) )
+		return;
+
+	// Get the column info and figure out how to interpret the data
+	ConvertFieldToText( m_pResultSet->GetColumnType( unColumn ), pubData, cubData, pchBuffer, cchBuffer, false );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copies a CSQLRecord to CRecordBase
+//-----------------------------------------------------------------------------
+bool CSQLRecord::BWriteToRecord( CRecordBase *pRecord, const CColumnSet & csWriteFields )
+{
+	bool bSuccess = true;
+	FOR_EACH_COLUMN_IN_SET( csWriteFields, unSQLColumn )
+	{
+		uint32 unRecordColumn = csWriteFields.GetColumn( unSQLColumn );
+
+		uint8 *pubData;
+		size_t cubData;
+		if( !BGetColumnData( unSQLColumn, &pubData, &cubData ) )
+		{
+			bSuccess = false;
+		}
+		else
+		{
+			bSuccess = pRecord->BSetField( unRecordColumn, pubData, cubData ) && bSuccess;
+		}
+
+	}
+	return bSuccess;
+}
+
+
+
+} // namespace GCSDK
diff --git a/gcsdk/sqlaccess/sqlutil.cpp b/gcsdk/sqlaccess/sqlutil.cpp
new file mode 100644
index 0000000..6744d21
--- /dev/null
+++ b/gcsdk/sqlaccess/sqlutil.cpp
@@ -0,0 +1,918 @@
+//========= 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
+{
+const char *GetInsertArgString()
+{
+	static char s_str[1024];
+	static bool s_bInit = false;
+
+	if ( !s_bInit )
+	{
+		for ( int i = 0; i < 1023; i++ )
+		{
+			s_str[i] = i % 2 == 0 ? '?' : ',';
+		}
+
+		s_str[1023] = NULL;
+		s_bInit = true;
+	}
+
+	return s_str;
+}
+
+uint32 GetInsertArgStringChars( uint32 nNumParams )
+{
+	AssertMsg( nNumParams <= GetInsertArgStringMaxParams(), "Error: Requested more characters than are provided by the GetInsertArgString" );
+	if( nNumParams == 0 )
+		return 0;
+
+	return nNumParams * 2 - 1;
+}
+
+uint32 GetInsertArgStringMaxParams()
+{
+	return 512;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Converts array of field data to text for SQL IN clause
+// Input:	columnInfo - schema of column being converted
+//			pubData - pointer to array of data to convert
+//			cubData - size of array of data
+//			rgchResult - pointer to output buffer
+//			cubResultLen - size of output buffer
+//			bForPreparedStatement - Should we prepare the text for a prepared statement or directly place the values?
+//-----------------------------------------------------------------------------
+void ConvertFieldArrayToInText( const CColumnInfo &columnInfo, byte *pubData, int cubData, char *rgchResult, int cubResultLen, bool bForPreparedStatement )
+{
+	int32 cubLength = columnInfo.GetFixedSize();
+	Assert( cubData % cubLength == 0 );
+	int32 nArrayCount = cubData / cubLength;
+
+	int32 len = 0;
+	rgchResult[len++] = '(';
+	for( int i = 0; i < nArrayCount; ++i )
+	{
+		if ( bForPreparedStatement )
+		{
+			if ( i < nArrayCount - 1 )
+			{
+				rgchResult[len++] = '?';
+				rgchResult[len++] = ',';	
+			}
+			else
+			{
+				rgchResult[len++] = '?';
+				rgchResult[len++] = ')';	
+			}
+		}
+		else
+		{
+			switch ( columnInfo.GetType() )
+			{
+			case k_EGCSQLType_int8:
+				if ( i < nArrayCount - 1 )
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d,", *( (byte *) pubData ) );
+				else
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d)", *( (byte *) pubData ) );
+				break;
+			case k_EGCSQLType_int16:
+				if ( i < nArrayCount - 1 )
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d,", *( (short *) pubData ) );
+				else
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d)", *( (short *) pubData ) );
+				break;
+			case k_EGCSQLType_int32:
+				if ( i < nArrayCount - 1 )
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d,", *( (int *) pubData ) );
+				else
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%d)", *( (int *) pubData ) );
+				break;
+			case k_EGCSQLType_int64:
+				if ( i < nArrayCount - 1 )
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%lld,", *( (int64 *) pubData ) );
+				else
+					len += Q_snprintf( rgchResult + len, cubResultLen - len, "%lld)", *( (int64 *) pubData ) );
+				break;
+			default:
+				AssertMsg( false, "Unsupported data type for non prepares statement with IN clause\n" );
+				rgchResult[0] = 0;
+				return;
+			}
+		}
+
+		if( len >= cubResultLen - 1 )
+		{
+			AssertMsg( false, "Generation of IN clause foverflowed\n" );
+			rgchResult[0] = 0;
+			return;
+		}
+		pubData += cubLength;
+	}
+
+	rgchResult[len] = 0;
+	return;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Converts field data to text equivalent for SQL statement
+// Input:	eFieldType - The type of the field to convert to text
+//			pubRecord - pointer to record data to convert
+//			cubRecord - size of record data
+//			rgchField - pointer to output buffer
+//			cchField - size of output buffer
+//-----------------------------------------------------------------------------
+void ConvertFieldToText( EGCSQLType eFieldType, uint8 *pubRecord, int cubRecord, char *rgchField, int cchField, bool bQuoteString )
+{
+	char rgchTmp[k_cMedBuff];
+
+	switch ( eFieldType )
+	{
+	case k_EGCSQLType_int8:
+		Q_snprintf( rgchField, cchField, "%d", *( (byte *) pubRecord ) );
+		break;
+	case k_EGCSQLType_int16:
+		Q_snprintf( rgchField, cchField, "%d", *( (short *) pubRecord ) );
+		break;
+	case k_EGCSQLType_int32:
+		Q_snprintf( rgchField, cchField, "%d", *( (int *) pubRecord ) );
+		break;
+	case k_EGCSQLType_int64:
+		Q_snprintf( rgchField, cchField, "%lld", *( (int64 *) pubRecord ) );
+		break;
+	case k_EGCSQLType_float:
+		Q_snprintf( rgchField, cchField, "%f", *((float*) pubRecord) );
+			break;
+	case k_EGCSQLType_double:
+		Q_snprintf( rgchField, cchField, "%f", *((double*) pubRecord) );
+		break;
+	case k_EGCSQLType_String:
+		if ( pubRecord && *pubRecord )
+		{
+			Assert( cubRecord + 1 < Q_ARRAYSIZE( rgchTmp ) );
+
+			Q_memcpy( rgchTmp, (char *) pubRecord, cubRecord );
+			rgchTmp[cubRecord] = 0;
+
+			if ( bQuoteString )
+			{
+				EscapeStringValue( rgchTmp, Q_ARRAYSIZE( rgchTmp ) );
+				Q_snprintf( rgchField, cchField, "'%s'", rgchTmp );
+			}
+			else
+			{
+				Q_strncpy( rgchField, rgchTmp, cchField );
+			}
+		}
+		else
+		{
+			if ( bQuoteString )
+			{
+				Q_strncpy( rgchField, "''", cchField );
+			}
+			else
+			{
+				Q_strncpy( rgchField, "", cchField );
+			}
+		}
+		break;
+	case k_EGCSQLType_Blob:
+	case k_EGCSQLType_Image:
+		Q_strncpy( rgchField, "0x", cchField );
+		Q_binarytohex( pubRecord, cubRecord, rgchField + 2, cchField - 2 );
+		break;
+	default:
+		Assert( false );
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the text SQL type for a given field
+// Input:	field - field to determine type for
+//			pchBuf - pointer to output buffer
+//			cchBuf - size of output buffer
+// Output:	returns pchBuf for convenience of one-line usage
+//-----------------------------------------------------------------------------
+char *SQLTypeFromField( const CColumnInfo &colInfo, char *pchBuf, int cchBuf )
+{
+	EGCSQLType eType = colInfo.GetType();
+	*pchBuf = 0;
+	switch ( eType )
+	{
+	case k_EGCSQLType_int8:
+		Q_strncpy( pchBuf, "TINYINT", cchBuf );
+		break;
+	case k_EGCSQLType_int16:
+		Q_strncpy( pchBuf, "SMALLINT", cchBuf );
+		break;
+	case k_EGCSQLType_int32:
+		Q_strncpy( pchBuf, "INT", cchBuf );
+		break;
+	case k_EGCSQLType_int64:
+		Q_strncpy( pchBuf, "BIGINT", cchBuf );
+		break;
+	case k_EGCSQLType_float:
+		Q_strncpy( pchBuf, "REAL", cchBuf );
+		break;
+	case k_EGCSQLType_double:
+		Q_strncpy( pchBuf, "FLOAT", cchBuf );
+		break;
+	case k_EGCSQLType_String:
+		Q_snprintf( pchBuf, cchBuf, "VARCHAR(%d)", colInfo.GetMaxSize() );
+		break;
+	case k_EGCSQLType_Blob:
+		Q_snprintf( pchBuf, cchBuf, "VARBINARY(%d)", colInfo.GetMaxSize() );
+		break;
+	case k_EGCSQLType_Image:
+		Q_strncpy( pchBuf, "IMAGE", cchBuf );
+		break;
+	default:
+		Assert( false );
+		break;
+	}
+
+	return pchBuf;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Escapes any single quotes to a string value to double single quotes
+// Input:	rgchField - text to escape
+//			cchField - size of text buffer
+// Notes:	The text will be escaped and expanded in place in the buffer.
+//			In the worst case, the text may expand by 2x.  (If the field is all
+//			single quotes.)  So, you must pass in a buffer which is at least
+//			twice as long as the text length so we can guarantee to be able to
+//			escape the string.
+//-----------------------------------------------------------------------------
+void EscapeStringValue( char *rgchField, int cchField )
+{
+	// TODO - what else do we need to escape?  %() ...
+	char *pubCur = rgchField;
+	int nLen = 0;
+	int cSingleQuotes = 0;
+
+	// This function gets called on every text field we write but most text fields
+	// don't need to be escaped, so try to be as fast as possible in the normal case.
+
+	// first, walk through the string and count the string length and number of single quotes
+	while ( *pubCur )
+	{
+		if ( '\'' == *pubCur )
+			cSingleQuotes++;
+		nLen ++;
+		pubCur++;
+	}
+
+	// if no single quotes, nothing to do
+	if ( !cSingleQuotes )
+		return;
+
+	// caller must pass in a buffer that's long enough for expansion
+	Assert( nLen + cSingleQuotes + 1 <= cchField );
+	if ( !( nLen + cSingleQuotes + 1 <= cchField ) )
+		return;
+
+	// We know exactly how many characters the string will expand by (the # of single quotes).  Walk backward
+	// and copy the characters into the right places.  This touches each character only once.
+	pubCur = rgchField + nLen + cSingleQuotes;
+	*pubCur = 0;
+	pubCur--;
+	while ( pubCur > rgchField && cSingleQuotes > 0 )
+	{
+		// read pointer is offset from write pointer by # of remaining single quotes
+		char *pubRead = pubCur - cSingleQuotes;
+		Assert( pubRead >= rgchField );
+		// copy each character
+		*pubCur = *pubRead;
+		if ( '\'' == *pubRead )
+		{
+			// if the character is a single quote, back up one more and insert another single quote to escape it
+			pubCur --;
+			*pubCur = '\'';
+			// decrement # of single quotes remaining
+			cSingleQuotes --;
+			Assert( cSingleQuotes >= 0 );
+		}
+		pubCur--;
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: Adds constraint information to a SQL command to add or remove constraint
+// Input:	pchTableName - name of table
+//			pchColumnName - name of column
+//			nColFlagConstraint - flag with which constraint to 
+//			bForAdd - whether constraint is being added or removed
+//			pchCmd - buffer to append SQL command to
+//			cchCmd - size of buffer
+//-----------------------------------------------------------------------------
+void AppendConstraint( const char *pchTableName, const char *pchColumnName, int nColFlagConstraint, bool bForAdd, 
+					  bool bClustered, CFmtStrMax & sCmd, int nFillFactor )
+{
+	Assert( pchTableName && pchTableName[0] );
+	Assert( pchColumnName && pchColumnName[0] );
+
+	switch ( nColFlagConstraint )
+	{
+	case k_nColFlagPrimaryKey:
+		sCmd.AppendFormat( " CONSTRAINT %s_%s_PrimaryKey", pchTableName, pchColumnName);
+		if ( bForAdd )
+		{
+			sCmd += " PRIMARY KEY ";
+			if ( bClustered )
+			{
+				sCmd.AppendFormat( " CLUSTERED WITH (FILLFACTOR = %d) ", nFillFactor );
+			}
+			else
+			{
+				sCmd += "NONCLUSTERED";
+			}
+		}
+		break;
+	case k_nColFlagUnique:
+		/* do nothing - the uniqueness will be handled by creation of an index */
+		break;
+	case k_nColFlagAutoIncrement:
+		sCmd += " IDENTITY";
+		break;
+	default:
+		AssertMsg( false, "CSQLThread::AppendContraint: invalid constraint type" );
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds constraint information to a SQL command to add or remove constraint
+// Input:	pRecordInfo - record info describing table
+//			pColumnInfo - record info describing column
+//			bForAdd - whether constraint is being added or removed
+//			pchCmd - buffer to append SQL command to
+//			cchCmd - size of buffer
+//-----------------------------------------------------------------------------
+void AppendConstraints( const CRecordInfo *pRecordInfo, const CColumnInfo *pColumnInfo, bool bForAdd, CFmtStrMax & sCmd )
+{
+	Assert( pRecordInfo != NULL );
+	Assert( pColumnInfo != NULL );
+
+	if ( pColumnInfo->BIsPrimaryKey() )
+	{
+		// any column in a PK can't be NULL.
+		if ( bForAdd )
+		{
+			sCmd += " NOT NULL";
+		}
+
+		// only add primary key constraint here if it is a single-column PK
+		if ( pRecordInfo->GetPrimaryKeyType() == k_EPrimaryKeyTypeSingle )
+		{
+			// get the fields on the primary key
+			const CUtlVector< FieldSet_t > &refFields = pRecordInfo->GetIndexFields( );
+			int nFillFactor = refFields.Element( pRecordInfo->GetPKIndex() ).GetFillFactor();
+			AppendConstraint( pRecordInfo->GetName(), pColumnInfo->GetName(), k_nColFlagPrimaryKey, bForAdd, pColumnInfo->BIsClustered(), sCmd, nFillFactor );
+		}
+	}
+	else if ( pColumnInfo->BIsUnique() )
+	{
+		AppendConstraint( pRecordInfo->GetName(), pColumnInfo->GetName(), k_nColFlagUnique, bForAdd, pColumnInfo->BIsClustered(), sCmd, 0 );
+	}
+	
+	if ( pColumnInfo->BIsAutoIncrement() )
+	{
+		AppendConstraint( pRecordInfo->GetName(), pColumnInfo->GetName(), k_nColFlagAutoIncrement, bForAdd, pColumnInfo->BIsClustered(), sCmd, 0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Generates the "CONSTRAINT ..." text for the table primary key
+//-----------------------------------------------------------------------------
+void BuildTablePKConstraintText( TSQLCmdStr *psStatement, CRecordInfo *pRecordInfo )
+{
+	const FieldSet_t& vecFields = pRecordInfo->GetPKFields( );
+
+	psStatement->sprintf( "CONSTRAINT %s_PrimaryKey PRIMARY KEY %s ( ",
+		pRecordInfo->GetName(), 
+		vecFields.IsClustered() ? "CLUSTERED" : "NONCLUSTERED" );
+
+	for ( int nField = 0; nField < vecFields.GetCount(); nField++ )
+	{
+		// what field is the next column in our index?
+		int nThisField = vecFields.GetField( nField );
+		const CColumnInfo& columnInfo = pRecordInfo->GetColumnInfo(nThisField);
+
+		if (nField != 0)
+		{
+			*psStatement += ", ";
+		}
+		*psStatement += columnInfo.GetName();
+	}
+
+	// close our list
+	*psStatement += ") ";
+
+	if ( vecFields.GetFillFactor() != 0 )
+	{
+		// non-default fill factor, so specify it
+		psStatement->AppendFormat( " WITH FILLFACTOR = %d ",
+			vecFields.GetFillFactor() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds constraint information to a SQL command to add or remove table-level constraints
+// Input:	pRecordInfo - record info describing table
+//			pchCmd - buffer to append SQL command to
+//			cchCmd - size of buffer
+//-----------------------------------------------------------------------------
+
+void AppendTableConstraints( CRecordInfo *pRecordInfo, CFmtStrMax & sCmd )
+{
+	// the only supported table constraint is for PKs or FKs
+	if ( pRecordInfo->GetPrimaryKeyType() == k_EPrimaryKeyTypeMulti )
+	{
+		TSQLCmdStr tmp;
+		BuildTablePKConstraintText( &tmp, pRecordInfo );
+		sCmd += ", ";
+		sCmd += tmp;
+	}
+
+	// Look for FKs required on this table
+	// the only supported table constraint is for PKs or FKs
+	int cFKs = pRecordInfo->GetFKCount();
+	for( int i=0; i < cFKs; ++i )
+	{
+		FKData_t &fkData = pRecordInfo->GetFKData( i );
+
+		CFmtStr sColumns, sParentColumns;
+		FOR_EACH_VEC( fkData.m_VecColumnRelations, nCol )
+		{
+			FKColumnRelation_t &colRelation = fkData.m_VecColumnRelations[nCol];
+			if ( nCol > 0)
+			{
+				sColumns += ",";
+				sParentColumns += ",";
+			}
+			sColumns += colRelation.m_rgchCol;
+			sParentColumns += colRelation.m_rgchParentCol;
+		}
+
+		TSQLCmdStr sTmp;
+		sTmp.sprintf( ", CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s(%s) ON DELETE %s ON UPDATE %s",
+			fkData.m_rgchName, sColumns.Access(), fkData.m_rgchParentTableName, sParentColumns.Access(),
+			PchNameFromEForeignKeyAction( fkData.m_eOnDeleteAction ), PchNameFromEForeignKeyAction( fkData.m_eOnUpdateAction ) );
+
+		// add to the command
+		sCmd += sTmp;
+	}
+}
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL INSERT statement
+// Input:	psStatement - The string to put the statement into
+//			pRecordInfo - record info describing table inserting into
+//-----------------------------------------------------------------------------
+void BuildInsertStatementText( TSQLCmdStr *psStatement, const CRecordInfo *pRecordInfo )
+{
+	psStatement->sprintf("INSERT INTO %s.%s (", GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ), pRecordInfo->GetName() );
+
+	// build a string of the field names
+	int cColumns = pRecordInfo->GetNumColumns();
+	int nInsertable = 0;
+	bool bAddedBefore = false;
+	for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+		if ( !columnInfo.BIsInsertable() )
+			continue;
+
+		nInsertable++;
+
+		if ( bAddedBefore )
+			psStatement->Append( ',' );
+		bAddedBefore = true;
+		psStatement->Append( columnInfo.GetName() );
+	}
+	
+	psStatement->AppendFormat( ") VALUES (%.*s)", GetInsertArgStringChars( nInsertable ), GetInsertArgString() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL INSERT statement
+//			IMPORTANT NOTE - This Insert statement will use the Microsoft SQL Server 
+//			specific clause 'OUTPUT Inserted.ColumnName' 
+//			The result of that will be that the SQL statement will return to us 
+//			the columns that could not be specified by the Insert.
+//			At the time of writing, that is primarily AutoIncrement columns,
+//			however in theory we should be able to recover any computed column 
+//			from SQL server, with the caveats specified at : 
+//			http://msdn.microsoft.com/en-us/library/ms177564.aspx 
+//
+// Input:	psStatement - The output statement string
+//			pRecordInfo - record info describing table inserting into
+//-----------------------------------------------------------------------------
+
+void BuildInsertAndReadStatementText( TSQLCmdStr *psStatement, CUtlVector<int> *pvecOutputFields, const CRecordInfo *pRecordInfo )
+{
+	psStatement->sprintf("INSERT INTO %s.%s (", GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ), pRecordInfo->GetName() );
+
+	// build a string of the field names
+	int nInsertable = 0;
+	int cColumns = pRecordInfo->GetNumColumns();
+	bool bAddedBefore = false;
+	for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+		if ( !columnInfo.BIsInsertable() )
+			continue;
+
+		nInsertable++;
+
+		if ( bAddedBefore )
+			psStatement->Append( ',' );
+		bAddedBefore = true;
+		psStatement->Append( columnInfo.GetName() );
+	}
+
+	bAddedBefore = false ;	
+	int nOutputColumn = 0;
+	for( int iColumn = 0; iColumn < cColumns; iColumn++ )
+	{
+		const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn ) ;
+	
+		//
+		//	If we can't Insert it - we want SQL Server to tell us what value was stored
+		//	in the column !!
+		//
+		if( !columnInfo.BIsInsertable() )
+		{
+			if( bAddedBefore )
+				psStatement->Append( ", INSERTED." );
+			else
+				psStatement->Append( ") OUTPUT INSERTED." );
+			bAddedBefore = true ;
+			psStatement->Append( columnInfo.GetName() );
+			pvecOutputFields->AddToTail( iColumn );
+			nOutputColumn++;
+		}
+	}
+
+	// add field values to SQL statement
+	psStatement->AppendFormat( " VALUES (%.*s)", GetInsertArgStringChars( nInsertable ), GetInsertArgString() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL MERGE statement update or insert using in-flight values table
+// Input:	psStatement - The string to put the statement into
+//			pRecordInfo - record info describing table inserting into
+//-----------------------------------------------------------------------------
+void BuildMergeStatementTextOnPKWhenMatchedUpdateWhenNotMatchedInsert( TSQLCmdStr *psStatement, const CRecordInfo *pRecordInfo )
+{
+	psStatement->sprintf( "MERGE INTO %s.%s WITH( HOLDLOCK, ROWLOCK ) T USING ( VALUES (%.*s) ) AS S(",
+		GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ), pRecordInfo->GetName(),
+		GetInsertArgStringChars( pRecordInfo->GetNumColumns() ), GetInsertArgString() );
+
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( iColumn )
+				psStatement->Append( ',' );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( ") ON " );
+
+	// build a string of the PK columns
+	const FieldSet_t &fsPK = pRecordInfo->GetIndexFields()[pRecordInfo->GetPKIndex()];
+	{
+		int cColumns = fsPK.GetCount();
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( fsPK.GetField( iColumn ) );
+			if ( iColumn )
+				psStatement->Append( " AND " );
+			psStatement->Append( "T." );
+			psStatement->Append( columnInfo.GetName() );
+			psStatement->Append( "=S." );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( " WHEN MATCHED THEN UPDATE SET " );
+
+	// build the update string
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		bool bAddedBefore = false;
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			bool bThisColumnIsPartOfPK = false;
+			for ( int ipkCheck = 0; ipkCheck < fsPK.GetCount(); ++ipkCheck )
+			{
+				if ( iColumn == fsPK.GetField( ipkCheck ) )
+				{
+					bThisColumnIsPartOfPK = true;
+					break;
+				}
+			}
+			if ( bThisColumnIsPartOfPK )
+				continue;
+
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( bAddedBefore )
+				psStatement->Append( ',' );
+			bAddedBefore = true;
+			psStatement->Append( columnInfo.GetName() );
+			psStatement->Append( "=S." );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( " WHEN NOT MATCHED BY TARGET THEN INSERT (" );
+
+	// build a string of the field names
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		bool bAddedBefore = false;
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( !columnInfo.BIsInsertable() )
+				continue;
+
+			if ( bAddedBefore )
+				psStatement->Append( ',' );
+			bAddedBefore = true;
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( ") VALUES (" );
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		bool bAddedBefore = false;
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( !columnInfo.BIsInsertable() )
+				continue;
+
+			if ( bAddedBefore )
+				psStatement->Append( ',' );
+			bAddedBefore = true;
+			psStatement->Append( "S." );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+	psStatement->Append( ");" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL MERGE statement using CTE_MergeParams as supplied table holding rows
+// Input:	psStatement - The string to put the statement into
+//			pRecordInfo - record info describing table inserting into
+//-----------------------------------------------------------------------------
+void BuildMergeStatementTextOnPKWhenNotMatchedInsert( TSQLCmdStr *psStatement, const CRecordInfo *pRecordInfo )
+{
+	psStatement->sprintf( "MERGE INTO %s.%s WITH( HOLDLOCK, ROWLOCK ) T USING ( VALUES (%.*s) ) AS S(",
+		GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ), pRecordInfo->GetName(),
+		GetInsertArgStringChars( pRecordInfo->GetNumColumns() ), GetInsertArgString() );
+
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( iColumn )
+				psStatement->Append( ',' );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( ") ON " );
+
+	// build a string of the PK columns
+	const FieldSet_t &fsPK = pRecordInfo->GetIndexFields()[pRecordInfo->GetPKIndex()];
+	{
+		int cColumns = fsPK.GetCount();
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( fsPK.GetField( iColumn ) );
+			if ( iColumn )
+				psStatement->Append( " AND " );
+			psStatement->Append( "T." );
+			psStatement->Append( columnInfo.GetName() );
+			psStatement->Append( "=S." );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( " WHEN NOT MATCHED BY TARGET THEN INSERT (" );
+
+	// build a string of the field names
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		bool bAddedBefore = false;
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( !columnInfo.BIsInsertable() )
+				continue;
+
+			if ( bAddedBefore )
+				psStatement->Append( ',' );
+			bAddedBefore = true;
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+
+	psStatement->Append( ") VALUES (" );
+	{
+		int cColumns = pRecordInfo->GetNumColumns();
+		bool bAddedBefore = false;
+		for ( int iColumn = 0; iColumn < cColumns; iColumn++ )
+		{
+			const CColumnInfo &columnInfo = pRecordInfo->GetColumnInfo( iColumn );
+			if ( !columnInfo.BIsInsertable() )
+				continue;
+
+			if ( bAddedBefore )
+				psStatement->Append( ',' );
+			bAddedBefore = true;
+			psStatement->Append( "S." );
+			psStatement->Append( columnInfo.GetName() );
+		}
+	}
+	psStatement->Append( ");" );
+}
+
+void BuildSelectStatementText( TSQLCmdStr *psStatement, const CColumnSet & selectSet, const char *pchTopClause )
+{
+	*psStatement = "SELECT ";
+
+	if( pchTopClause )
+	{
+		psStatement->Append( pchTopClause );
+		psStatement->Append( ' ' );
+	}
+
+	// build a string of the field names
+	bool bAddedBefore = false;
+	FOR_EACH_COLUMN_IN_SET( selectSet, nColumnIndex )
+	{
+		const CColumnInfo &columnInfo = selectSet.GetColumnInfo( nColumnIndex );
+		if ( bAddedBefore )
+			psStatement->Append( ',' );
+		bAddedBefore = true;
+		psStatement->Append( columnInfo.GetName() );
+	}
+
+	psStatement->Append( " FROM ");
+	psStatement->Append( GSchemaFull().GetDefaultSchemaNameForCatalog( selectSet.GetRecordInfo()->GetESchemaCatalog() ) );
+	psStatement->Append( '.' );
+	psStatement->Append( selectSet.GetRecordInfo()->GetName() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL UPDATE statement
+// Input:	pRecordInfo - record info describing table inserting into
+//			bForPreparedStatement - if true, inserts values as '?' for later
+//				binding.  If false, values are inserted in text.
+//			pchStatement - pointer to buffer to build statement in
+//			cchStatement - size of buffer
+//			pSQLRecord - pointer to record with data to update
+//			iColumnMatch - column to use for WHERE condition
+//			pvMatch - data value to use for WHERE condition
+//			cubMatch - size of pvMatch data
+//			rgiColumnUpdate - array of column #'s to update
+//			ciColumnUpdate - count of column #'s to update
+//-----------------------------------------------------------------------------
+void BuildUpdateStatementText( TSQLCmdStr *psStatement, const CColumnSet & updateColumns )
+{
+	// build the UPDATE statement
+	psStatement->sprintf( "UPDATE %s.%s SET ", GSchemaFull().GetDefaultSchemaNameForCatalog( updateColumns.GetRecordInfo()->GetESchemaCatalog() ), updateColumns.GetRecordInfo()->GetName() );
+
+	// add each field we're updating to the UPDATE statement
+	FOR_EACH_COLUMN_IN_SET( updateColumns, nColumnIndex )
+	{
+		const CColumnInfo &columnInfo = updateColumns.GetColumnInfo( nColumnIndex );
+
+		if( nColumnIndex > 0 )
+			psStatement->Append( ',' );
+		psStatement->Append( columnInfo.GetName() );
+		psStatement->Append( "=?" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a SQL UPDATE statement
+//-----------------------------------------------------------------------------
+void BuildDeleteStatementText( TSQLCmdStr *psStatement, const CRecordInfo *pRecordInfo )
+{
+	psStatement->sprintf( "DELETE FROM %s.%s", GSchemaFull().GetDefaultSchemaNameForCatalog( pRecordInfo->GetESchemaCatalog() ), pRecordInfo->GetName() );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds a where clause for the provided fields
+//-----------------------------------------------------------------------------
+void AppendWhereClauseText( TSQLCmdStr *psClause, const CColumnSet & columnSet )
+{
+	// add each field we're updating to the UPDATE statement
+	FOR_EACH_COLUMN_IN_SET( columnSet, nColumnIndex )
+	{
+		const CColumnInfo &columnInfo = columnSet.GetColumnInfo( nColumnIndex );
+
+		if( nColumnIndex > 0 )
+			psClause->Append( " AND ");
+		psClause->Append( columnInfo.GetName() );
+		psClause->Append( "=?" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds an OUTPUT [fields] INTO [table] for the provided fields/data
+//-----------------------------------------------------------------------------
+void BuildOutputClauseText( TSQLCmdStr *psClause, const CColumnSet & columnSet )
+{
+	*psClause = " OUTPUT ";
+
+	FOR_EACH_COLUMN_IN_SET( columnSet, nColumnIndex )
+	{
+		const CColumnInfo &columnInfo = columnSet.GetColumnInfo( nColumnIndex );
+
+		if( nColumnIndex > 0 )
+			psClause->Append( ", ");
+		
+		psClause->Append( " ? AS " );
+		psClause->Append( columnInfo.GetName() );
+	}
+
+	psClause->Append( " INTO " );
+	psClause->Append( columnSet.GetRecordInfo()->GetName() );
+}
+
+////-----------------------------------------------------------------------------
+//// Purpose: our own special "upsert" into a column with a uniqueness constraint
+////-----------------------------------------------------------------------------
+//EResult UpdateOrInsertUnique( CSQLAccess &sqlAccess, int iTable, int iField, CRecordBase *pRecordBase, int iIndexID )
+//{
+//	// attempt an update - if it fails due to duplicate primary key, they can't use this
+//	// url (it's taken) - if it succeeds but affects 0 rows, they didn't have a vanity url
+//	// and we need to do an insert (which could again fail due to primary key constraints)
+//	int cRecordsUpdated = 0;	
+//	bool bRet = sqlAccess.BYieldingUpdateFieldFromRecordWithIndex( iTable, &cRecordsUpdated, iField, pRecordBase, iIndexID );
+//	if ( !bRet )
+//	{ 
+//		// ODBC is the suck - give me Spring JDBC templates, please.
+//		if ( sqlAccess.GetLastError()->IsDuplicateInsertAttempt() )  
+//		{
+//			return k_EResultDuplicateName;
+//		}
+//		return k_EResultFail;
+//	}
+//	else if ( 0 == cRecordsUpdated )
+//	{
+//		// the user didn't have an entry, so insert one.
+//		bRet = sqlAccess.BYieldingInsertRecord( iTable, pRecordBase );
+//		if ( !bRet )
+//		{ 
+//			// ODBC is the suck - give me Spring JDBC templates, please.
+//			if ( sqlAccess.GetLastError()->IsDuplicateInsertAttempt() )  
+//			{
+//				return k_EResultDuplicateName;
+//			}
+//			return k_EResultFail;
+//		}
+//	}
+//	return k_EResultOK;
+//}
+//
+
+} // namespace GCSDK