tf2/tf2_src/gcsdk/sqlaccess/sqlutil.cpp

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