source-engine/gcsdk/sqlaccess/sqlaccess.cpp

//========= 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