/**********************************************************************
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
********************************************************************/
/*************************************************************************
**************************************************************************/
//
// MODULE: NetConnect.cpp
//
//
// PURPOSE: Krypton - Client Module 
//
//
#include "process.h"

#include "DrvrGlobal.h"
#include "DrvrNet.h"
#include "CStmt.h"
#include "DiagFunctions.h"
#include "tdm_odbcDrvMsg.h"
#include "odbc_cl.h"
#include "ceecfg.h"
#include "ping.h"
#include "nskieee.h"
#include "sqlcli.h"
#include "odbcs_drvr.h"

using namespace ODBC;

SQLRETURN SQLPREPARE_(SRVR_CALL_CONTEXT *srvrCallContext)
{
	CEE_status	sts;
	SQLRETURN	rc;

	IDL_long	returnCode = 0;
	BYTE       *sqlWarningOrError = NULL;
	IDL_long	sqlStmtQueryType;
	IDL_long	stmtHandle;
	IDL_long	estimatedCost = 0;
	IDL_char   *stmtOptions = NULL;
	BYTE       *inputParams = NULL;
	SQLItemDescList_def inputDesc = {0,0};
	BYTE       *outputColumns = NULL;
	SQLItemDescList_def outputDesc = {0,0};

	CStmt *pStatement = (CStmt *)srvrCallContext->sqlHandle;

	sts = odbc_SQLDrvr_Prepare_pst_(
					srvrCallContext,
					stmtOptions,
					&returnCode,
					sqlWarningOrError,
					&sqlStmtQueryType,
					&stmtHandle,
					&estimatedCost,
					inputParams,
					&inputDesc,
					outputColumns,
					&outputDesc);

	if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error","SQLPREPARE_");
		else if (sts == TIMEOUT_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem())); 
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S01, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S02, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,"SQLPREPARE_ failed");
		return SQL_ERROR;
	}

	pStatement->setExceptionErrors(returnCode, 0);
	switch (returnCode) 
	{
		case SQL_SUCCESS:
		case SQL_SUCCESS_WITH_INFO:

			if(sqlStmtQueryType == SQL_CALL_NO_RESULT_SETS ||
		       sqlStmtQueryType == SQL_CALL_WITH_RESULT_SETS ||
			   sqlStmtQueryType == SQL_SP_RESULT_SET )
			{
				//
				// Need to save the input/output params descriptors for SPJ calls
				// since users can prepare once and execute multiple times
				//
				if(inputDesc._length > 0)
				{
					pStatement->m_spjInputParamDesc._length = inputDesc._length;
					pStatement->m_spjInputParamDesc._buffer = new SQLItemDesc_def[pStatement->m_spjInputParamDesc._length];
					memcpy(pStatement->m_spjInputParamDesc._buffer,inputDesc._buffer, inputDesc._length * sizeof(SQLItemDesc_def));
				}
				else
				{
					if(pStatement->m_spjInputParamDesc._length &&
						pStatement->m_spjInputParamDesc._buffer != NULL)
						delete[] pStatement->m_spjInputParamDesc._buffer;

					pStatement->m_spjInputParamDesc._length = 0;
					pStatement->m_spjInputParamDesc._buffer = NULL;
				}

				if(outputDesc._length > 0)
				{
					pStatement->m_spjOutputParamDesc._length = outputDesc._length;
					pStatement->m_spjOutputParamDesc._buffer = new SQLItemDesc_def[pStatement->m_spjOutputParamDesc._length];
					memcpy(pStatement->m_spjOutputParamDesc._buffer,outputDesc._buffer, outputDesc._length * sizeof(SQLItemDesc_def));
				}
				else
				{
					if(pStatement->m_spjOutputParamDesc._length &&
						pStatement->m_spjOutputParamDesc._buffer != NULL)
						delete[] pStatement->m_spjOutputParamDesc._buffer;

					pStatement->m_spjOutputParamDesc._length = 0;
					pStatement->m_spjOutputParamDesc._buffer = NULL;
				}


				rc = pStatement->setDescRec(&pStatement->m_spjInputParamDesc, &pStatement->m_spjOutputParamDesc);
			}
			else
				rc = pStatement->setDescRec(&inputDesc, &outputDesc);


		   pStatement->setExceptionErrors(rc);
		   pStatement->setStmtQueryType(sqlStmtQueryType);
		   pStatement->setStmtHandle(stmtHandle);
		   pStatement->setStmtData(inputParams, outputColumns);
		   if (returnCode != SQL_SUCCESS)
		      pStatement->setDiagRec(sqlWarningOrError, returnCode);
		   break;

		case SQL_STILL_EXECUTING:
   		   break;

		case SQL_ERROR:
		   pStatement->setDiagRec(sqlWarningOrError, returnCode);
		   break;	

		case SQL_INVALID_HANDLE:
		   pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
		   break;

		default:
		   pStatement->sendCDInfo(returnCode);
		   pStatement->setDiagRec(returnCode, PREPARE_PROCNAME, pStatement->getSrvrIdentity());
		   break;
	}


	if (sqlWarningOrError != NULL)
		delete sqlWarningOrError;

	if (inputParams != NULL)
		delete inputParams;

	if (inputDesc._buffer != NULL)
	{
		delete inputDesc._buffer;
		inputDesc._length = 0;
		inputDesc._buffer = NULL;
	}
	if (outputColumns != NULL)
		delete outputColumns;

	if (outputDesc._buffer != NULL)
	{
		delete outputDesc._buffer;
		outputDesc._length = 0;
		outputDesc._buffer = NULL;
	}
	
	return (SQLRETURN)returnCode;

} /* SQLPREPARE_() */

SQLRETURN SQLFETCH_(SRVR_CALL_CONTEXT *srvrCallContext)
{
	CEE_status	sts;
	IDL_long    stmtHandle = 0;
	IDL_long    returnCode = 0;
	IDL_long	outValuesFormat = 0;	
	IDL_long    rowsReturned= 0;
	BYTE       *sqlWarningOrError = 0;
	IDL_char   *stmtOptions = NULL;
	IDL_long			stmtQueryType=-1;
	SQL_DataValue_def	outputDataValue={0,0};

	IDL_unsigned_long Index=0;
	IDL_unsigned_long Items=0;
	IDL_unsigned_long rowLength=0;
	IDL_long count;
	IDL_long colnumber;
	IDL_long rowNumber=0;

	SQLINTEGER              SQLCharset=0;
	SQLSMALLINT             SQLDataType=0;
	SQLSMALLINT             SQLDatetimeCode=0;
	SQLINTEGER              SQLOctetLength=0;
	SQLSMALLINT             SQLPrecision=0;
	SQLSMALLINT             SQLUnsigned=0;

	IDL_short               SQLDataInd=0;
	IDL_short               SQLDataLength=0;
	BYTE*                   SQLDataValue;
	BOOL                    byteSwap;

	CStmt *pStatement = (CStmt *)srvrCallContext->sqlHandle;
	if (pStatement->m_isClosed)
		return SQL_NO_DATA_FOUND;


	DWORD preFetchThreadStatus;
	if (pStatement->m_preFetchThread.m_Thread != NULL)
	{
		if(pStatement->m_preFetchThread.m_State == PREFETCH_STATE_WRK_STARTED ||
		   pStatement->m_preFetchThread.m_State == PREFETCH_STATE_WRK_DONE)
		   // the prefetch thread is fetching or is done
		{
			GetExitCodeThread(pStatement->m_preFetchThread.m_Thread, &preFetchThreadStatus);
			if (preFetchThreadStatus == STILL_ACTIVE)
			   WaitForSingleObject(pStatement->m_preFetchThread.m_Thread,INFINITE);
			GetExitCodeThread(pStatement->m_preFetchThread.m_Thread, &preFetchThreadStatus);
			sts = preFetchThreadStatus;
			CloseHandle(pStatement->m_preFetchThread.m_Thread);
			pStatement->m_preFetchThread.m_Thread = NULL;
			pStatement->m_preFetchThread.m_State = PREFETCH_STATE_WRK_UNASSIGNED;

			returnCode = pStatement->m_preFetchThread.returnCode;
			sqlWarningOrError = pStatement->m_preFetchThread.sqlWarningOrError;
			rowsReturned = pStatement->m_preFetchThread.rowsReturned;
			outValuesFormat = pStatement->m_preFetchThread.outValuesFormat;
			outputDataValue._length = pStatement->m_preFetchThread.outputDataValue._length;
			outputDataValue._buffer = pStatement->m_preFetchThread.outputDataValue._buffer;
			pStatement->m_preFetchThread.initializeResults();
		}
		else
		{
			// fetch data synchronously
			sts = odbc_SQLDrvr_Fetch_pst_(
					srvrCallContext,
					stmtOptions,
					&returnCode,
					sqlWarningOrError,
					&rowsReturned,
					&outValuesFormat,
					&outputDataValue);
		}
	}
	else
	{
		pStatement->m_preFetchThread.initializeResults();

		sts = odbc_SQLDrvr_Fetch_pst_(
				srvrCallContext,
				stmtOptions,
				&returnCode,
				sqlWarningOrError,
				&rowsReturned,
				&outValuesFormat,
				&outputDataValue);
	}

	SQLUINTEGER maxLength = pStatement->getMaxLength();
	SQL_DataValue_def       *DataValue = &outputDataValue;
	stmtHandle = pStatement->getStmtHandle();

	if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error","SQLFETCH_");
		else if (sts == TIMEOUT_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem())); 
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S01, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S02, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,"SQLFETCH_ failed");
		return SQL_ERROR;
	}


	
	pStatement->setExceptionErrors(returnCode, 0);
	CConnect *pConnection = pStatement->getConnectHandle();

	switch (returnCode)
	{
	case SQL_SUCCESS:
	case SQL_SUCCESS_WITH_INFO:
		
		pStatement->setDiagRowCount(rowsReturned, -1);
		pStatement->setRowCount(rowsReturned);

		if (returnCode != SQL_SUCCESS)
			pStatement->setDiagRec(sqlWarningOrError, returnCode);

		stmtQueryType = pStatement->getStmtQueryType();

		if(!pStatement->getFetchCatalog()) //if (stmtQueryType == 10000)
		{
			if (!pStatement->setFetchOutputPerf(DataValue, rowsReturned))
			{
				pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000_06);
				pStatement->clearFetchDataValue();
				return SQL_ERROR;
			}
		}
		else // Hack! To take care of the catalog APIs, should be removed once refactored code is in 
		{
			if (!pStatement->setFetchOutputPerf(rowsReturned, DataValue))
			{
				pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000_06);
				pStatement->clearFetchDataValue();
				break;
			}
		}

		byteSwap = pStatement->getByteSwap();
		count = pStatement->getImpDescCount();

		if(!pStatement->getFetchCatalog()) // if (stmtQueryType == 10000)
		{
			
			if(rowsReturned > 0)
				rowLength = DataValue->_length / rowsReturned;
			
			for (int rowOffset=0, row =0; row < rowsReturned; row++)
			{
				pStatement->setRowAddress(row,(DataValue->_buffer + rowOffset));
				rowOffset += rowLength;
			}
		}
		else	//With RWRS, only catalog API data takes this path
		{
			while (Index < DataValue->_length)
			{
				if (Items % count == 0)
				{
					rowNumber++;
					pStatement->setRowAddress(Items/count,DataValue->_buffer + Index);
				}
				SQLDataInd = (short)*(unsigned char*)(DataValue->_buffer + Index);
				if (SQLDataInd == 0)
				{
					colnumber = Items % count + 1;
					pStatement->getImpSQLData(colnumber, SQLCharset, SQLDataType, SQLDatetimeCode, SQLOctetLength, SQLPrecision,SQLUnsigned);
					SQLDataValue = DataValue->_buffer + Index + 1;
					if (byteSwap)
						SQLDatatype_Dependent_Swap(SQLDataValue, SQLDataType, SQLCharset, SQLOctetLength);
					
					Index = Index + dataLengthFetchPerf(SQLDataType, SQLOctetLength, maxLength, SQLCharset, SQLDataValue);
				}
				Index = Index + 1;
				Items++;
			}
		}

		break;

	case SQL_STILL_EXECUTING:
		break;

	case SQL_NO_DATA_FOUND:
		break;

	case SQL_ERROR:
		pStatement->setDiagRec(sqlWarningOrError, returnCode);
		break;

	case SQL_INVALID_HANDLE:
		pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
		break;

	default:
		pStatement->sendCDInfo(returnCode);
		pStatement->setDiagRec(returnCode, EXECUTE_PROCNAME, pStatement->getSrvrIdentity());
		break;
	}

	if (sqlWarningOrError != NULL)
	    delete sqlWarningOrError;

	if ( returnCode == SQL_SUCCESS_WITH_INFO || returnCode == SQL_SUCCESS )
	{
		if((pStatement->m_Concurrency == SQL_CONCUR_READ_ONLY) && (pStatement->m_AsyncEnable != SQL_ASYNC_ENABLE_ON))
		{
			if (pStatement->m_preFetchThread.m_Thread == NULL)
			{
				if ((pStatement->m_preFetchThread.m_Thread = (HANDLE)_beginthreadex(NULL, 0, odbc_SQLDrvr_PreFetch_pst_, 
							pStatement, CREATE_SUSPENDED, NULL)) > 0)
				{
					ResumeThread(pStatement->m_preFetchThread.m_Thread);
					pStatement->m_preFetchThread.m_State = PREFETCH_STATE_WRK_ASSIGNED;
				}
			}
		}
	}
	else if (pStatement->m_preFetchThread.m_Thread != NULL)
	{
		if( !(pStatement->m_preFetchThread.m_State == PREFETCH_STATE_WRK_STARTED ||
		      pStatement->m_preFetchThread.m_State == PREFETCH_STATE_WRK_DONE) )
		   pStatement->m_preFetchThread.m_State = PREFETCH_STATE_WRK_CANCELLED;
	}

	return (SQLRETURN)returnCode;

} /* SQLFETCH_() */


SQLRETURN FREESTATEMENT(SRVR_CALL_CONTEXT *srvrCallContext)
{
	CEE_status	sts;

	CStmt    *pStatement = (CStmt *)srvrCallContext->sqlHandle;
	CConnect *pConnection = pStatement->getConnectHandle();
	IDL_long returnCode = 0;
	IDL_long rowsAffected = 0;
	BYTE     *sqlWarningOrError = 0;

	if (srvrCallContext->SQLSvc_ObjRef[0] == 0)
		return SQL_SUCCESS;

	DWORD preFetchThreadStatus;
	if (pStatement->m_preFetchThread.m_Thread != NULL)
	{
		GetExitCodeThread(pStatement->m_preFetchThread.m_Thread, &preFetchThreadStatus);
		if (preFetchThreadStatus == STILL_ACTIVE)
		{
		   LeaveCriticalSection(&pConnection->m_CSTransmision);
		   WaitForSingleObject(pStatement->m_preFetchThread.m_Thread,INFINITE);
	       EnterCriticalSection(&pConnection->m_CSTransmision);
		}
		GetExitCodeThread(pStatement->m_preFetchThread.m_Thread, &preFetchThreadStatus);
		CloseHandle(pStatement->m_preFetchThread.m_Thread);
		pStatement->m_preFetchThread.m_Thread = NULL;
	}
	pStatement->m_preFetchThread.initializeResults();


	// Destroy the previous proxy if needed

	sts = odbc_SQLDrvr_Close_pst_(srvrCallContext,
							      &returnCode,
							      &rowsAffected,
							      sqlWarningOrError);

	
	if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error","FREESTATEMENT");
		else if (sts == TIMEOUT_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem())); 
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S01, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S02, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,"FREESTATEMENT failed");
		return SQL_ERROR;
	}
	
	pStatement->setExceptionErrors(returnCode, 0);

	// Start CCF
	switch (returnCode) 
	{
	   case SQL_SUCCESS:
       case SQL_SUCCESS_WITH_INFO:
	      pStatement->setDiagRowCount(rowsAffected, -1);
		  pStatement->setRowCount(rowsAffected);
          if(returnCode == SQL_SUCCESS_WITH_INFO)
 	         pStatement->setDiagRec(sqlWarningOrError, returnCode);
		  break;
		  
	   case SQL_ERROR:
	      pStatement->setDiagRec(sqlWarningOrError, returnCode);
		  break;

	   default:
	      pStatement->sendCDInfo(returnCode);
		  pStatement->setDiagRec(returnCode, FREESTATEMENT_PROCNAME, pStatement->getSrvrIdentity());
		  break;
	}
    // End of CCF

	
	if (sqlWarningOrError != NULL)
		delete sqlWarningOrError;
	
	return (SQLRETURN)returnCode;
}


SQLRETURN SMDCATALOGS(SRVR_CALL_CONTEXT *srvrCallContext)
{
	CEE_status	sts;
	SQLRETURN	rc;

    struct odbc_SQLSvc_GetSQLCatalogs_exc_ exception_ = {0,0,0};
    SQLItemDescList_def outputItemDescList = {0,0};
	ERROR_DESC_LIST_def sqlWarning = {0,0};
	IDL_string catStmtLabel = NULL;

	CStmt *pStatement = (CStmt *)srvrCallContext->sqlHandle;

	sts = odbc_SQLDrvr_GetSQLCatalogs_pst_(
									srvrCallContext,
									&catStmtLabel,
									&outputItemDescList,
                                    &exception_,
									&sqlWarning);
    if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error","FREESTATEMENT");
		else if (sts == TIMEOUT_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem())); 
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S01, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S02, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,"FREESTATEMENT failed");
		return SQL_ERROR;
	}

    odbc_SQLSvc_GetSQLCatalogs_ccf_ (srvrCallContext,
                                     &exception_,
                                     catStmtLabel,
                                     &outputItemDescList,
                                     &sqlWarning);


	//
	// Cleanup
	//
	if(outputItemDescList._length > 0)
		delete[] outputItemDescList._buffer;


	if(exception_.exception_nr == odbc_SQLSvc_GetSQLCatalogs_SQLError_exn_ &&
	   exception_.u.SQLError.errorList._length > 0 )
  	      delete[] exception_.u.SQLError.errorList._buffer;

	if(sqlWarning._length > 0)
		delete[] sqlWarning._buffer;


	rc = checkNetStmt(srvrCallContext,sts,"SMDCATALOGS");
	return rc;

} // SMDCATALOGS()

// Call Completion function for odbc_SQLSvc_GetSQLCatalogs

extern "C" void 
odbc_SQLSvc_GetSQLCatalogs_ccf_ (
	CEE_tag_def cmptag_
  , const odbc_SQLSvc_GetSQLCatalogs_exc_ *exception_
  , const IDL_char *catStmtLabel
  , const SQLItemDescList_def *outputDesc
  , const ERROR_DESC_LIST_def *sqlWarning)
{

	SRVR_CALL_CONTEXT	*srvrCallContext = (SRVR_CALL_CONTEXT *)cmptag_;
	CStmt				*pStatement = (CStmt *)srvrCallContext->sqlHandle;
	SQLRETURN			rc;

	pStatement->setExceptionErrors(exception_->exception_nr, exception_->exception_detail);
	switch (exception_->exception_nr) 
	{
	case CEE_SUCCESS:
		pStatement->setStmtLabel(catStmtLabel);
		rc = pStatement->setDescRec(NULL, outputDesc);
		pStatement->setExceptionErrors(rc);
		if (sqlWarning->_length > 0)
			pStatement->setDiagRec(sqlWarning);
		break;
	case odbc_SQLSvc_GetSQLCatalogs_SQLError_exn_:
		pStatement->setDiagRec(&exception_->u.SQLError);
		break;
	case odbc_SQLSvc_GetSQLCatalogs_InvalidConnection_exn_:
		pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
		break;
	case odbc_SQLSvc_GetSQLCatalogs_ParamError_exn_:
		pStatement->setDiagRec(SERVER_ERROR, IDS_HY_C00, exception_->exception_nr, 
				exception_->u.ParamError.ParamDesc, NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, pStatement->getSrvrIdentity());
		break;
	case odbc_SQLSvc_GetSQLCatalogs_SQLInvalidHandle_exn_:
		break;
	default:
		pStatement->sendCDInfo(exception_->exception_nr);
		pStatement->setDiagRec(exception_->exception_nr, SMDCATALOGS_PROCNAME, pStatement->getSrvrIdentity());
		break;
	}
	
}


// Call Completion function for a ExecDirect or ExecDirect rowset

extern "C" void
odbc_SQLSvc_ExecDirect_ccf_(
    CEE_tag_def cmptag_
  , const odbc_SQLSvc_ExecDirect_exc_ *exception_
  , IDL_long estimatedCost
  , const SQLItemDescList_def *outputDesc
  , IDL_long rowsAffected
  , const ERROR_DESC_LIST_def *sqlWarning
  )
{
	
	SRVR_CALL_CONTEXT	*srvrCallContext = (SRVR_CALL_CONTEXT *)cmptag_;
	CStmt				*pStatement = (CStmt *)srvrCallContext->sqlHandle;
	SQLRETURN			rc;

	pStatement->setExceptionErrors(exception_->exception_nr, exception_->exception_detail);
	switch (exception_->exception_nr) 
	{
	case CEE_SUCCESS:
		rc = pStatement->setDescRec(NULL, outputDesc);
		pStatement->setExceptionErrors(rc);
		if (sqlWarning->_length > 0)
			pStatement->setDiagRec(sqlWarning);
		pStatement->setDiagRowCount(rowsAffected, -1);
		pStatement->setRowCount(rowsAffected);
		if (estimatedCost == SQL_SELECT_UNIQUE)
		   estimatedCost = SQL_SELECT_NON_UNIQUE;
		// Vijay - Set the statement type to SELECT using estimatedCost to get the QueryType from SQL/Server
		pStatement->setStmtQueryType(estimatedCost);
		break;
	case odbc_SQLSvc_ExecDirect_SQLStillExecuting_exn_:
		break;
	case odbc_SQLSvc_ExecDirect_SQLQueryCancelled_exn_:
		pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_008, exception_->u.SQLQueryCancelled.sqlcode);
		break;
	case odbc_SQLSvc_ExecDirect_SQLError_exn_:
		pStatement->setDiagRec(&exception_->u.SQLError);
		break;	
	case odbc_SQLSvc_ExecDirect_ParamError_exn_:
		if ((pStatement->m_intStmtType == TYPE_QS) || (pStatement->m_intStmtType == TYPE_CMD))
			pStatement->setDiagRec(SERVER_ERROR, IDS_S1_000, 0, exception_->u.ParamError.ParamDesc,NULL, 0, 0, 1, exception_->u.ParamError.ParamDesc);
		else
			pStatement->setDiagRec(SERVER_ERROR, IDS_PROGRAM_ERROR, exception_->exception_nr, 
				exception_->u.ParamError.ParamDesc, NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, pStatement->getSrvrIdentity());
		break;
	case odbc_SQLSvc_ExecDirect_InvalidConnection_exn_:
		pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
		break;
	case odbc_SQLSvc_ExecDirect_TransactionError_exn_:
		char tmpNumBuffer[16];
		_itoa (exception_->exception_detail, tmpNumBuffer, 10);
		pStatement->setDiagRec(SERVER_ERROR, IDS_TRANSACTION_ERROR, exception_->exception_nr, 
				tmpNumBuffer, NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1, pStatement->getSrvrIdentity());
	default:
		pStatement->sendCDInfo(exception_->exception_nr);
		pStatement->setDiagRec(exception_->exception_nr, EXECDIRECT_PROCNAME, pStatement->getSrvrIdentity());
		break;
	}
}


SQLRETURN checkNetStmt(SRVR_CALL_CONTEXT *srvrCallContext,CEE_status sts, char* procname)
{
	SQLRETURN	rc;

	CStmt *pStatement = (CStmt *)srvrCallContext->sqlHandle;
	if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error",procname);
		else if (sts == TIMEOUT_EXCEPTION)
		{
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, 0, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
			pStatement->Cancel();
		}
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01, 0, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(SERVER_ERROR, IDS_08_S02, 0, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,procname);

		return SQL_ERROR;
	}

	switch (srvrCallContext->odbcAPI)
	{
	case SQL_API_SQLPREPARE:
	case SQL_API_SQLEXECDIRECT:
	case SQL_API_SQLPARAMDATA:

	default:
		switch (pStatement->getExceptionNr())
		{	
		case CEE_SUCCESS:
			if (pStatement->getSQLWarning())
				rc = SQL_SUCCESS_WITH_INFO;
			else
				rc = SQL_SUCCESS;
			break;
		default:
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_API_SQLEXECUTE:
		switch (pStatement->getExceptionNr())
		{	
		case CEE_SUCCESS:
			if (pStatement->getSQLWarning())
				rc = SQL_SUCCESS_WITH_INFO;
			else
				rc = SQL_SUCCESS;
			break;
		case odbc_SQLSvc_ExecuteRowset_SQLInvalidHandle_exn_:
			rc = SQL_INVALID_HANDLE;
			break;
		case odbc_SQLSvc_ExecuteRowset_SQLStillExecuting_exn_:
			rc = SQL_STILL_EXECUTING;
			break;
		case odbc_SQLSvc_ExecuteRowset_SQLNeedData_exn_:
			rc = SQL_NEED_DATA;
			break;
		case SQL_NO_DATA_FOUND:
			rc = SQL_NO_DATA;
			break;
		default:
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_API_SQLEXTENDEDFETCH:
	case SQL_API_SQLFETCH:
		switch (pStatement->getExceptionNr())
		{	
		case CEE_SUCCESS:
			if (pStatement->getNumberOfRows() == 0 )
				rc = SQL_ERROR;
			else
			{
				if (pStatement->getSQLWarning())
					rc = SQL_SUCCESS_WITH_INFO;
				else
					rc = SQL_SUCCESS;
			}
			break;
		case odbc_SQLSvc_FetchRowset_SQLInvalidHandle_exn_:
			rc = SQL_INVALID_HANDLE;
			break;
		case odbc_SQLSvc_FetchRowset_SQLStillExecuting_exn_:
			rc = SQL_STILL_EXECUTING;
			break;
		case odbc_SQLSvc_FetchRowset_SQLNoDataFound_exn_:
			rc = SQL_NO_DATA;
			break;
		case SQL_NO_DATA_FOUND:
			rc = SQL_NO_DATA;
			break;
		default:
			rc = SQL_ERROR;
			break;
		}
		break;
	case SQL_API_SQLTABLES:
	case SQL_API_SQLCOLUMNS:
	case SQL_API_SQLPRIMARYKEYS:
	case SQL_API_SQLSPECIALCOLUMNS:
	case SQL_API_SQLSTATISTICS:
	case SQL_API_SQLGETTYPEINFO:
	case SQL_API_SQLPROCEDURES:
	case SQL_API_SQLPROCEDURECOLUMNS:
		switch (pStatement->getExceptionNr())
		{	
		case CEE_SUCCESS:
			if (pStatement->getSQLWarning())
				rc = SQL_SUCCESS_WITH_INFO;
			else
				rc = SQL_SUCCESS;
			break;
		case odbc_SQLSvc_GetSQLCatalogs_SQLInvalidHandle_exn_:
			rc = SQL_INVALID_HANDLE;
			break;
		default:
			rc = SQL_ERROR;
			break;
		}
		break;
	}
	return rc;
}



SQLRETURN SQLEXECUTE_(SRVR_CALL_CONTEXT *srvrCallContext)
{

	CEE_status			sts;
	SQLRETURN			rc = SQL_ERROR;
	IDL_long			stmtHandle = 0;
	IDL_long			returnCode = 0;
	IDL_long_long		rowsAffected = 0;
	IDL_long            sqlStmtQueryType = 0;
	IDL_long            estimatedCost = 0;
	BYTE				*sqlWarningOrError = 0;


	SQL_DataValue_def	outputDataValue = {0,0};   // output from execute and execute with rowset
	SQLItemDescList_def outputItemDescList = {0,0};// output from execdirect and execdirect rowset
	SQLValueList_def    inputValueList = {0,0};    // input for ExecuteCall

	IDL_unsigned_long rowLength=0;

	IDL_unsigned_long	Index=0;
	IDL_unsigned_long	Items=0;


	SQLINTEGER		SQLCharset=0;
	SQLSMALLINT		SQLDataType=0; 
	SQLSMALLINT		SQLDatetimeCode=0;
	SQLINTEGER		SQLOctetLength=0; 
	SQLSMALLINT		SQLPrecision=0;
	SQLSMALLINT		SQLUnsigned=0;
	SQLINTEGER		SQLMaxLength=0; 
	SQLSMALLINT		SQLNullable=0;

	IDL_short		SQLDataInd=0;
	IDL_short		SQLDataLength=0;
	BYTE*			outputColumns = NULL; // ExecDirect on the server calls Prepare/Execute


	CStmt *pStatement = (CStmt *)srvrCallContext->sqlHandle;
	CConnect *pConnection = pStatement->getConnectHandle();

	sqlStmtQueryType = pStatement->getStmtQueryType();

	SQLUINTEGER maxLength = pStatement->getMaxLength();
	SQL_DataValue_def	*DataValue = &outputDataValue;
	SQLUINTEGER maxRowCount = srvrCallContext->u.executeParams.rowCount;

	stmtHandle = pStatement->getStmtHandle();

	

	if (pConnection->m_srvrTCPIPSystem->odbcAPI == SRVR_API_SQLEXECDIRECT)
	{

		sts = odbc_SQLDrvr_Execute_pst_(srvrCallContext,
						srvrCallContext->dialogueId,
						srvrCallContext->u.sendSQLcommandParams.asyncEnable,
						srvrCallContext->u.sendSQLcommandParams.holdableCursor,
						srvrCallContext->u.sendSQLcommandParams.queryTimeout,
						0, // input rowCount
						srvrCallContext->maxRowsetSize,
						srvrCallContext->u.sendSQLcommandParams.sqlStmtType,
						stmtHandle,
						srvrCallContext->u.sendSQLcommandParams.sqlStmtType, // statement type
						(char *)srvrCallContext->u.sendSQLcommandParams.sqlString,
						srvrCallContext->u.sendSQLcommandParams.cursorName,
						srvrCallContext->u.sendSQLcommandParams.stmtLabel,
						srvrCallContext->u.sendSQLcommandParams.stmtName, // stmt explain label
                       		                &inputValueList,
			                        &returnCode,
			                        sqlWarningOrError,
			                        &rowsAffected,
						&sqlStmtQueryType,
                                        	&estimatedCost,
			                        &outputDataValue,
                                        	&outputItemDescList,
						outputColumns // for ExecDirect (prepare returns this)
						);
		if (sts == CEE_SUCCESS)
		{
			pStatement->setStmtQueryType(sqlStmtQueryType);
			switch (returnCode) 
			{
				case SQL_SUCCESS:
				case SQL_SUCCESS_WITH_INFO:
					pStatement->setDiagRowCount(rowsAffected, -1);
					pStatement->setRowCount(rowsAffected);

					if (sqlStmtQueryType == SQL_SELECT_UNIQUE && rowsAffected > 0)
					{
						if (!pStatement->setFetchOutputPerf(DataValue, rowsAffected))
						{
							pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000_06);
							pStatement->clearFetchDataValue();
							break;
						}
						

						pStatement->setRowAddress(0,(DataValue->_buffer)); // only one row

					} // Unique Select

					if( sqlStmtQueryType == SQL_CALL_NO_RESULT_SETS ||
						sqlStmtQueryType == SQL_CALL_WITH_RESULT_SETS ||
						sqlStmtQueryType == SQL_SP_RESULT_SET )
					{

						pStatement->setDescRec(&pStatement->m_spjInputParamDesc, &pStatement->m_spjOutputParamDesc);

						if(DataValue->_buffer != NULL)
						{
							pStatement->setFetchOutputPerf(DataValue, rowsAffected);
							pStatement->setRowAddress(0,(DataValue->_buffer));
							pStatement->setExecuteCallOutputs();
						}

						if(pStatement->m_spjNumResultSets > 0)
						{
							// set the descriptors for the first result set. We'll set the other ones when the
							// user calls SQLMoreResults
							pStatement->setDescRec(&pStatement->m_spjInputParamDesc, &pStatement->m_spjResultSets[0].spjOutputItemDesc);
						}

					} // Execute Call With Outut Params

					if(returnCode == SQL_SUCCESS_WITH_INFO)
						pStatement->setDiagRec(sqlWarningOrError, returnCode);

					break;
				case SQL_STILL_EXECUTING:
					break;
				case SQL_NO_DATA_FOUND:
					break;
				case SQL_ERROR:
					pStatement->setDiagRec(sqlWarningOrError, returnCode);
					break;
				case SQL_INVALID_HANDLE:
					pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
					break;
				default:
					pStatement->sendCDInfo(returnCode);
					pStatement->setDiagRec(returnCode, EXECDIRECT_PROCNAME, pStatement->getSrvrIdentity());
					break;
			} // switch on returnCode
		} // sts == CEE_SUCCESS

		rc = (SQLRETURN)returnCode;

	} // SRVR_API_SQLEXECDIRECT



    if (pConnection->m_srvrTCPIPSystem->odbcAPI == SRVR_API_SQLEXECUTE2)
	{

		sts = odbc_SQLDrvr_Execute_pst_(srvrCallContext,
						srvrCallContext->dialogueId,
						srvrCallContext->u.executeParams.asyncEnable,
						srvrCallContext->u.executeParams.holdableCursor,				
						srvrCallContext->u.executeParams.queryTimeout,
						srvrCallContext->u.executeParams.rowCount, // input rowCount
						srvrCallContext->maxRowsetSize,
						srvrCallContext->u.executeParams.sqlStmtType,
						stmtHandle,
						srvrCallContext->u.executeParams.sqlStmtType, // statement type
						NULL, // sql string
						srvrCallContext->u.executeParams.cursorName,
						NULL, // stmt Label
						NULL, // stmt explain label
                                        	srvrCallContext->u.executeParams.inputValueList,
			                        &returnCode,
			                        sqlWarningOrError,
			                        &rowsAffected,
						&sqlStmtQueryType,
                                        	&estimatedCost,
			                        &outputDataValue,
                                        	&outputItemDescList,
						outputColumns // for ExecDirect (prepare returns this)
						);

		if (sts == CEE_SUCCESS)
		{
			pStatement->setExceptionErrors(returnCode, 0);
			switch (returnCode) 
			{
				case SQL_SUCCESS:
				case SQL_SUCCESS_WITH_INFO:
					
					pStatement->setDiagRowCount(rowsAffected, -1);
					pStatement->setRowCount(rowsAffected);
					sqlStmtQueryType = pStatement->getStmtQueryType();
					if (returnCode != SQL_SUCCESS)
					{
						if( pStatement->rowsetWasFiltered() )
							pStatement->mapSqlRowIdsToDrvrRowIds(sqlWarningOrError);/*AMR */

						pStatement->setDiagRec(sqlWarningOrError, returnCode);
					}
					
					if (sqlStmtQueryType == SQL_SELECT_UNIQUE && rowsAffected > 0)
					{

						if (!pStatement->setFetchOutputPerf(DataValue, rowsAffected))
						{
							pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000_06);
							pStatement->clearFetchDataValue();
							break;
						}

						pStatement->setRowAddress(0,(DataValue->_buffer)); // only one row
					

					} // Unique Select

					if( sqlStmtQueryType == SQL_CALL_NO_RESULT_SETS ||
						sqlStmtQueryType == SQL_CALL_WITH_RESULT_SETS ||
						sqlStmtQueryType == SQL_SP_RESULT_SET )
					{

						pStatement->setDescRec(&pStatement->m_spjInputParamDesc, &pStatement->m_spjOutputParamDesc);

						if(DataValue->_buffer != NULL)
						{
							pStatement->setFetchOutputPerf(DataValue, rowsAffected);
							pStatement->setRowAddress(0,(DataValue->_buffer));
							pStatement->setExecuteCallOutputs();
						}

						if(pStatement->m_spjNumResultSets > 0)
						{
							// set the descriptors for the first result set. We'll set the other ones when the
							// user calls SQLMoreResults
							pStatement->setDescRec(&pStatement->m_spjInputParamDesc, &pStatement->m_spjResultSets[0].spjOutputItemDesc);
						}

					} // Execute Call With Outut Params

			  		if (pStatement->getStmtType() == TYPE_INSERT_PARAM ||
					    pStatement->getStmtType() == TYPE_UPDATE ||
					    pStatement->getStmtType() == TYPE_DELETE) 
					{
						if (pStatement->rowsetErrorRecovery())
						{
							if (rowsAffected == -1)
								pStatement->setExceptionErrors(odbc_SQLSvc_ExecuteRowset_SQLError_exn_,0);
			//				else
			//					pStatement->setExceptionErrors(returnCode, 0);

							if (returnCode != SQL_SUCCESS)
								pStatement->setRowsetArrayStatus(sqlWarningOrError, rowsAffected);
						}
						else
						{
							pStatement->setExceptionErrors (returnCode, 0);
							if (returnCode != SQL_SUCCESS)  /*AMR*/
							{
								if( pStatement->rowsetWasFiltered() )							
									pStatement->mapSqlRowIdsToDrvrRowIds(sqlWarningOrError);/*AMR */

								pStatement->setRowsetArrayStatus(sqlWarningOrError, rowsAffected);
							}
						}
					}
					break;
				case SQL_STILL_EXECUTING:
					break;
				case SQL_NO_DATA_FOUND:
					break;
				case SQL_ERROR:
					if( pStatement->rowsetWasFiltered() )							
						pStatement->mapSqlRowIdsToDrvrRowIds(sqlWarningOrError);/*AMR*/

					if (pStatement->getStmtType() == TYPE_INSERT_PARAM ||
					    pStatement->getStmtType() == TYPE_UPDATE ||
					    pStatement->getStmtType() == TYPE_DELETE) 
						   pStatement->setRowsetArrayStatus(sqlWarningOrError, -1);

					pStatement->setDiagRec(sqlWarningOrError, returnCode);
					break;
				case SQL_INVALID_HANDLE:
					pStatement->setDiagRec(SERVER_ERROR, IDS_08_S01);
					break;
				default:
					pStatement->sendCDInfo(returnCode);
					pStatement->setDiagRec(returnCode, EXECUTE_PROCNAME, pStatement->getSrvrIdentity());
					break;
			} // switch on returnCode
		} // sts == CEE_SUCCESS

		rc = (SQLRETURN)returnCode;

	} // SRVR_API_SQLEXECUTE2




	if (sts != CEE_SUCCESS)
	{
		if (sts == CEE_INTERNALFAIL)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_EXCEPTION_MSG,0,"SQL SERVER",
				NULL,SQL_ROW_NUMBER_UNKNOWN,SQL_COLUMN_NUMBER_UNKNOWN,2,"Internal Error","SQLEXECUTE_");
		else if (sts == TIMEOUT_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_T00, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem())); 
		else if (sts == COMM_LINK_FAIL_EXCEPTION)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S01, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else if (sts == TRANSPORT_ERROR)
			pStatement->setDiagRec(DRIVER_ERROR, IDS_08_S02, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()));
		else
			pStatement->setDiagRec(DRIVER_ERROR, IDS_S1_000, sts, FORMAT_ERROR((long)pStatement->getSrvrTCPIPSystem()), NULL, 
				SQL_ROW_NUMBER_UNKNOWN, SQL_COLUMN_NUMBER_UNKNOWN, 1,"SQLEXECUTE_ failed");
		return SQL_ERROR;
	}



	//
	// Cleanup
	//
	if (sqlWarningOrError != NULL)
		delete sqlWarningOrError;

	if(outputItemDescList._length > 0)
		delete[] outputItemDescList._buffer;

	pStatement->clearInputValueList();
	
	return rc;

} /* SQLEXECUTE_() */