Example #1
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_getDescriptor( IIAPI_GETDESCRPARM II_FAR *getDescrParm )
{
    IIAPI_HNDL	*handle;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )
	( "IIapi_getDescriptor: retrieving columns from server\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! getDescrParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getDescriptor: null getDescriptor parameters\n" );
	return;
    }
    
    getDescrParm->gd_genParm.gp_completed = FALSE;
    getDescrParm->gd_genParm.gp_status = IIAPI_ST_SUCCESS;
    getDescrParm->gd_genParm.gp_errorHandle = NULL;
    getDescrParm->gd_descriptorCount = 0;
    getDescrParm->gd_descriptor = NULL;
    handle = (IIAPI_HNDL *)getDescrParm->gd_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getDescriptor: API is not initialized\n" );
	IIapi_appCallback( &getDescrParm->gd_genParm, NULL, 
			   IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    if ( ( ! IIapi_isStmtHndl( (IIAPI_STMTHNDL *)handle )  &&  
           ! IIapi_isDbevHndl( (IIAPI_DBEVHNDL *)handle ) )  ||
	 IIAPI_STALE_HANDLE( handle ) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getDescriptor: invalid handle\n" );
	IIapi_appCallback( &getDescrParm->gd_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    IIAPI_TRACE( IIAPI_TR_INFO )
	( "IIapi_getDescriptor: handle = %p\n", handle );
    
    IIapi_clearAllErrors( handle );
    IIapi_uiDispatch( IIAPI_EV_GETDESCR_FUNC, handle, (II_PTR)getDescrParm );

    return;
}
Example #2
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_getCopyMap( IIAPI_GETCOPYMAPPARM II_FAR *getCopyMapParm )
{
    IIAPI_STMTHNDL	*stmtHndl;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )
	( "IIapi_getCopyMap: retrieving copy information from server\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! getCopyMapParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getCopyMap: null getCopyMap parameters\n" );
	return;
    }
    
    getCopyMapParm->gm_genParm.gp_completed = FALSE;
    getCopyMapParm->gm_genParm.gp_status = IIAPI_ST_SUCCESS;
    getCopyMapParm->gm_genParm.gp_errorHandle = NULL;
    stmtHndl = (IIAPI_STMTHNDL *)getCopyMapParm->gm_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getCopyMap: API is not initialized\n" );
	IIapi_appCallback( &getCopyMapParm->gm_genParm, NULL, 
			   IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    if ( ! IIapi_isStmtHndl( stmtHndl )  ||  IIAPI_STALE_HANDLE( stmtHndl ) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_getCopyMap: invalid statement handle\n" );
	IIapi_appCallback( &getCopyMapParm->gm_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_getCopyMap: stmtHndl = %p\n", stmtHndl );
    
    IIapi_clearAllErrors( (IIAPI_HNDL *)stmtHndl );
    
    IIapi_uiDispatch( IIAPI_EV_GETCOPYMAP_FUNC, 
		      (IIAPI_HNDL *)stmtHndl, (II_PTR)getCopyMapParm );

    return;
}
Example #3
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_autocommit( IIAPI_AUTOPARM II_FAR *autoParm )
{
    IIAPI_TRANHNDL	*tranHndl;
    IIAPI_CONNHNDL	*connHndl;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )("IIapi_autocommit: set autocommit state\n");
    
    /*
    ** Validate Input parameters
    */
    if ( ! autoParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: null autocommit parameters\n" );
	return;
    }
    
    autoParm->ac_genParm.gp_completed = FALSE;
    autoParm->ac_genParm.gp_status = IIAPI_ST_SUCCESS;
    autoParm->ac_genParm.gp_errorHandle = NULL;
    connHndl = (IIAPI_CONNHNDL *)autoParm->ac_connHandle;
    tranHndl = (IIAPI_TRANHNDL *)autoParm->ac_tranHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: API is not initialized\n" );
	IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			   IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    if ( ! connHndl  &&  ! tranHndl )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: no handle provided\n" );
	IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }

    if ( connHndl  &&  
	 (! IIapi_isConnHndl( connHndl )  ||  IIAPI_STALE_HANDLE( connHndl )) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: invalid connection handle\n" );
	IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }

    if ( tranHndl  &&  
	 (! IIapi_isTranHndl( tranHndl )  ||  IIAPI_STALE_HANDLE( tranHndl )) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: invalid transaction handle\n" );
	IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }

    IIAPI_TRACE( IIAPI_TR_INFO )
	( "IIapi_autocommit: connHndl = %p, tranHndl = %p\n",
	  autoParm->ac_connHandle, autoParm->ac_tranHandle );
    
    if ( connHndl )  IIapi_clearAllErrors( (IIAPI_HNDL *)connHndl );
    if ( tranHndl )  IIapi_clearAllErrors( (IIAPI_HNDL *)tranHndl );

    if ( ! tranHndl  &&  ! IIapi_isQueEmpty( &connHndl->ch_tranHndlList ) )
    {
	/*
	** Application is attempting to enable autocommit mode 
	** with an active transaction.
	*/
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_autocommit: can't enable autocommit in a transaction\n" );

	if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				 E_AP0003_ACTIVE_TRANSACTIONS, 
				 II_SS25000_INV_XACT_STATE,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &autoParm->ac_genParm, 
			       (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	return;
    }
	
    if ( tranHndl  &&  ! IIapi_isQueEmpty( &tranHndl->th_stmtHndlList ) )
    {
	/*
	** Application is attempting to disable autocommit mode
	** with active statements.
	*/
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ("IIapi_autocommit: can't disable autocommit with active statements\n");

	if ( ! IIapi_localError( (IIAPI_HNDL *)tranHndl, 
				 E_AP0004_ACTIVE_QUERIES, 
				 II_SS25000_INV_XACT_STATE,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &autoParm->ac_genParm, 
			       (IIAPI_HNDL *)tranHndl, IIAPI_ST_FAILURE );
	return;
    }
    
    if ( ! tranHndl )
    {
	/*
	** Enable autocommit mode.  Create a transaction handle
	** and return it to the application.
	*/
	if ( ! ( tranHndl = IIapi_createTranHndl( NULL, connHndl ) ) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_autocommit: createTranHndl failed\n" );
	    IIapi_appCallback( &autoParm->ac_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	    return;
	}

	autoParm->ac_tranHandle = (II_PTR)tranHndl;
    }
    else
    {
	/*
	** Disable autocommit mode.  The transaction handle
	** will be deleted, so clear the output parameter.
	*/
	autoParm->ac_tranHandle = NULL;
    }
    
    IIapi_uiDispatch( IIAPI_EV_AUTO_FUNC, 
		      (IIAPI_HNDL *)tranHndl, (II_PTR)autoParm );

    return;
}
Example #4
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_scroll( IIAPI_SCROLLPARM II_FAR *scrollParm )
{
    IIAPI_STMTHNDL	*stmtHndl;
    IIAPI_CONNHNDL	*connHndl;
    bool		valid;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )( "IIapi_scroll: scroll cursor\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! scrollParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_scroll: null scrollParms parameters\n" );
	return;
    }
    
    scrollParm->sl_genParm.gp_completed = FALSE;
    scrollParm->sl_genParm.gp_status = IIAPI_ST_SUCCESS;
    scrollParm->sl_genParm.gp_errorHandle = NULL;
    stmtHndl = (IIAPI_STMTHNDL *)scrollParm->sl_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_scroll: API is not initialized\n" );
	IIapi_appCallback( &scrollParm->sl_genParm, 
			   NULL, IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    if ( 
    	 ! IIapi_isStmtHndl( stmtHndl )  ||  
	 IIAPI_STALE_HANDLE( stmtHndl )  ||
	 ! (connHndl = IIapi_getConnHndl( (IIAPI_HNDL *)stmtHndl))
       )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_scroll: invalid handle %p\n", stmtHndl );
	IIapi_appCallback( &scrollParm->sl_genParm, 
			   NULL, IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_scroll: handle = %p\n", stmtHndl );
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_scroll: orientation = %d, offset = %d\n", 
	    scrollParm->sl_orientation, scrollParm->sl_offset );
    
    IIapi_clearAllErrors( (IIAPI_HNDL *)stmtHndl );
    
    /*
    ** Validate parameters.
    */
    switch( scrollParm->sl_orientation )
    {
    case IIAPI_SCROLL_NEXT :
	valid = TRUE;
	break;

    case IIAPI_SCROLL_BEFORE :
    case IIAPI_SCROLL_FIRST :
    case IIAPI_SCROLL_PRIOR :
    case IIAPI_SCROLL_CURRENT :
    case IIAPI_SCROLL_LAST :
    case IIAPI_SCROLL_AFTER :
    case IIAPI_SCROLL_ABSOLUTE :
    case IIAPI_SCROLL_RELATIVE :
	if ( connHndl->ch_partnerProtocol >= GCA_PROTOCOL_LEVEL_67 )
	    valid = TRUE;
	else
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_scroll: scrolling not supported\n" );
	    valid = FALSE;
	}
    	break;

    default :
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_scroll: invalid orientation: %d\n",
	      (II_LONG)scrollParm->sl_orientation );
	valid = FALSE;
	break;
    }

    if ( ! valid )
    {
	if ( ! IIapi_localError( (IIAPI_HNDL *)stmtHndl, 
				 E_AP0011_INVALID_PARAM_VALUE, 
				 II_SS22003_NUM_VAL_OUT_OF_RANGE, 
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &scrollParm->sl_genParm, 
			       NULL, IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &scrollParm->sl_genParm, 
	    		       (IIAPI_HNDL *)stmtHndl, IIAPI_ST_FAILURE );
        return;
    }

    IIapi_uiDispatch( IIAPI_EV_SCROLL_FUNC, 
    		      (IIAPI_HNDL *)stmtHndl, (II_PTR)scrollParm );
    return;
}
Example #5
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_position( IIAPI_POSPARM II_FAR *posParm )
{
    IIAPI_STMTHNDL	*stmtHndl;
    IIAPI_CONNHNDL	*connHndl;
    bool		valid;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )( "IIapi_position: position cursor\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! posParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_position: null posParms parameters\n" );
	return;
    }
    
    posParm->po_genParm.gp_completed = FALSE;
    posParm->po_genParm.gp_status = IIAPI_ST_SUCCESS;
    posParm->po_genParm.gp_errorHandle = NULL;
    stmtHndl = (IIAPI_STMTHNDL *)posParm->po_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_position: API is not initialized\n" );
	IIapi_appCallback( &posParm->po_genParm, 
			   NULL, IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    if ( 
    	 ! IIapi_isStmtHndl( stmtHndl )  ||
	 IIAPI_STALE_HANDLE( stmtHndl )  ||
         ! (connHndl = IIapi_getConnHndl( (IIAPI_HNDL *)stmtHndl ))
       )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_position: invalid handle %p\n", stmtHndl );
	IIapi_appCallback( &posParm->po_genParm, 
			   NULL, IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_position: handle = %p\n", stmtHndl );
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_position: reference = %d, offset = %d, rows = %d\n", 
	    posParm->po_reference, posParm->po_offset, posParm->po_rowCount );
    
    IIapi_clearAllErrors( (IIAPI_HNDL *)stmtHndl );
    
    /*
    ** Validate parameters.
    */
    switch( posParm->po_reference )
    {
    case IIAPI_POS_BEGIN :
    case IIAPI_POS_END :
	if ( connHndl->ch_partnerProtocol >= GCA_PROTOCOL_LEVEL_67 )
	    valid = TRUE;
	else
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_scroll: scrolling not supported\n" );
	    valid = FALSE;
	}
    	break;

    case IIAPI_POS_CURRENT :
	if ( connHndl->ch_partnerProtocol >= GCA_PROTOCOL_LEVEL_67  ||
	     posParm->po_offset == 1 )
	    valid = TRUE;
	else
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_scroll: scrolling not supported\n" );
	    valid = FALSE;
	}
	break;

    default :
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_position: invalid reference: %d\n",
	      (II_LONG)posParm->po_reference );
	valid = FALSE;
	break;
    }

    if ( posParm->po_rowCount < 
         ((connHndl->ch_partnerProtocol >= GCA_PROTOCOL_LEVEL_67) ? 0 : 1) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_position: invalid row count: %d\n",
	      (II_LONG)posParm->po_rowCount );
	valid = FALSE;
    }

    if ( ! valid )
    {
	if ( ! IIapi_localError( (IIAPI_HNDL *)stmtHndl, 
				 E_AP0011_INVALID_PARAM_VALUE, 
				 II_SS22003_NUM_VAL_OUT_OF_RANGE, 
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &posParm->po_genParm, 
			       NULL, IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &posParm->po_genParm, 
	    		       (IIAPI_HNDL *)stmtHndl, IIAPI_ST_FAILURE);
        return;
    }
    
    IIapi_uiDispatch( IIAPI_EV_POSITION_FUNC, 
    		      (IIAPI_HNDL *) stmtHndl, (II_PTR)posParm );
    return;
}
Example #6
0
static II_BOOL
sm_execute
(
    IIAPI_ACTION        action,
    IIAPI_HNDL          *ev_hndl,
    IIAPI_HNDL          *sm_hndl,
    II_PTR              parmBlock
)
{
    IIAPI_TRANHNDL      *tranHndl = (IIAPI_TRANHNDL *)sm_hndl;
    IIAPI_MSG_BUFF      *msgBuff;
    IIAPI_STATUS        status;
    II_BOOL             success = TRUE;
    char		queryText[ 64 ];

    switch( action )
    {
        case SQL_TA_REMC :
	    /*
	    ** Remember callback.
	    */
	    tranHndl->th_callback = TRUE;
	    tranHndl->th_parm = (IIAPI_GENPARM *)parmBlock;
	    break;

	case SQL_TA_RECV :
	{
	    /*
	    ** Issue receive message request.
	    */
	    IIAPI_MSG_BUFF *msgBuff = IIapi_allocMsgBuffer( sm_hndl );

	    if ( ! msgBuff )
		status = IIAPI_ST_OUT_OF_MEMORY;
	    else
		status = IIapi_rcvNormalGCA( sm_hndl, msgBuff, (II_LONG)(-1) );

	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;
	}
	case SQL_TA_SCOM :
	    /*
	    ** Format and send GCA_COMMIT message.
	    */
	    if ( ! (msgBuff = IIapi_allocMsgBuffer( sm_hndl )) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    msgBuff->msgType = GCA_COMMIT;
	    msgBuff->flags = IIAPI_MSG_EOD;
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;

	case SQL_TA_SRB :
	    /*
	    ** Format and send GCA_ROLLBACK message.
	    */
	    if ( ! (msgBuff = IIapi_allocMsgBuffer( sm_hndl )) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    msgBuff->msgType = GCA_ROLLBACK;
	    msgBuff->flags = IIAPI_MSG_EOD;
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;

	case SQL_TA_SSP :
	{
	    /*
	    ** Create savepoint handle.  Format and
	    ** send GCA_QUERY message 'savepoint <sp>'.
	    */
	    IIAPI_SAVEPTHNDL	*savePtHndl;
	    IIAPI_SAVEPTPARM    *savePtParm = (IIAPI_SAVEPTPARM *)parmBlock;

	    if ( ! IIapi_createSavePtHndl( savePtParm ) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }

	    savePtHndl = savePtParm->sp_savePointHandle;
	    STprintf( queryText, "savepoint %s\n", savePtHndl->sp_savePtName );

	    if ( ! (msgBuff = IIapi_createMsgQuery( sm_hndl, queryText )) )
	    {
		IIapi_deleteSavePtHndl( savePtHndl );
		savePtParm->sp_savePointHandle = NULL;
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );

	    if ( status != IIAPI_ST_SUCCESS )
	    {
		IIapi_deleteSavePtHndl( savePtHndl );
		savePtParm->sp_savePointHandle = NULL;
		success = FALSE;
	    }
	    break;
	}
	case SQL_TA_SRBS :
	{
	    /*
	    ** Format and send GCA_QUERY message 'rollback to <savepoint>'.
	    */
	    IIAPI_ROLLBACKPARM	*rollParm = (IIAPI_ROLLBACKPARM *)parmBlock;
	    IIAPI_SAVEPTHNDL	*savePtHndl = rollParm->rb_savePointHandle;

	    STprintf(queryText, "rollback to %s\n", savePtHndl->sp_savePtName);
    
	    if ( ! (msgBuff = IIapi_createMsgQuery( sm_hndl, queryText )) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;
	}
	case SQL_TA_SAON :
	    /*
	    ** Format and send GCA_QUERY message 'set autocommit on'.
	    */
	    if ( ! (msgBuff = IIapi_createMsgQuery( sm_hndl, 
						     "set autocommit on" )) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;

	case SQL_TA_SAOF :
	    /*
	    ** Format and send GCA_QUERY message 'set autocommit off'.
	    */
	    if ( ! (msgBuff = IIapi_createMsgQuery( sm_hndl,
						     "set autocommit off" )) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;

	case SQL_TA_SSEC :
	    /*
	    ** Format and send GCA_SECURE message.
	    */
	    if ( ! ( msgBuff = IIapi_createMsgSecure( tranHndl ) ) )
	    {
		status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
    
	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;

	case SQL_TA_SXAS :
	{
	    /*
	    ** Send XA Start message.
	    */
	    IIAPI_XASTARTPARM *startParm = (IIAPI_XASTARTPARM *)parmBlock;

	    if ( ! (msgBuff = IIapi_createMsgXA( sm_hndl, GCA_XA_START,
	    				&startParm->xs_tranID.ti_value.xaXID,
					startParm->xs_flags )) )
	    {
	    	status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }

	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;
	}
	case SQL_TA_SXAE :
	{
	    /*
	    ** Send XA End message.
	    */
	    IIAPI_XAENDPARM *endParm = (IIAPI_XAENDPARM *)parmBlock;

	    if ( ! (msgBuff = IIapi_createMsgXA( sm_hndl, GCA_XA_END,
	    				&endParm->xe_tranID.ti_value.xaXID,
					endParm->xe_flags )) )
	    {
	    	status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }

	    status = IIapi_sndGCA( sm_hndl, msgBuff, NULL );
	    if ( status != IIAPI_ST_SUCCESS )  success = FALSE;
	    break;
	}
	case SQL_TA_PEND :
	    /*
	    ** Return transaction aborted to all pending operations.
	    */
	    {
		IIAPI_STMTHNDL	*stmtHndl;

		for( 
		     stmtHndl = (IIAPI_STMTHNDL *)tranHndl->
						th_stmtHndlList.q_next;
		     stmtHndl != (IIAPI_STMTHNDL *)&tranHndl->th_stmtHndlList;
		     stmtHndl = (IIAPI_STMTHNDL *)stmtHndl->
						sh_header.hd_id.hi_queue.q_next
		   )
		    IIapi_abortStmtHndl( stmtHndl, 
					 E_AP0002_TRANSACTION_ABORTED,
					 II_SS40001_SERIALIZATION_FAIL, 
					 IIAPI_ST_FAILURE );
	    }
	    break;

	case SQL_TA_DELH :
	    /*
	    ** Mark handle for deletion.
	    */
	    QUremove( (QUEUE *)tranHndl );
	    sm_hndl->hd_delete = TRUE;

	    /*
	    ** If this was a distributed transaction, 
	    ** the associated distributed transaction 
	    ** name should be releasable during the 
	    ** callback.  Since the transaction handle 
	    ** has not actually been deleted, it is 
	    ** still associated with the distributed 
	    ** transaction name.  Normally, cases such
	    ** as this are serialized by the dispatch
	    ** operations queue, but IIapi_releaseXID()
	    ** is not a dispatched request.  So we need
	    ** to drop the association prior to making
	    ** the callback.
	    */
	    if ( tranHndl->th_tranName )  
	    {
		QUremove( &tranHndl->th_tranNameQue );
		tranHndl->th_tranName = NULL;
	    }
	    break;

	case SQL_TA_DELX :
	    /*
	    ** Free associated transaction name handle.
	    */
	    if ( tranHndl->th_tranName )  	/* Should never be NULL */
	    {
		QUremove( &tranHndl->th_tranNameQue );
		IIapi_deleteTranName( tranHndl->th_tranName );
		tranHndl->th_tranName = NULL;
	    }

	    /*
	    ** Mark handle for deletion.
	    */
	    QUremove( (QUEUE *)tranHndl );
	    sm_hndl->hd_delete = TRUE;
	    break;

	case SQL_TA_ERAB :
	    /*
	    ** Transaction Aborted.
	    */
            IIAPI_TRACE( IIAPI_TR_ERROR )
                ( "%s: Transaction aborted\n", sql_tran_sm.sm_id );

	    if ( ! IIapi_localError( sm_hndl, E_AP0002_TRANSACTION_ABORTED, 
				     II_SS40001_SERIALIZATION_FAIL,
				     IIAPI_ST_FAILURE ) )
	    {
	        status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
	    }
	    break;

	case SQL_TA_ERCF :
	    /*
	    ** Commit failed.
	    */
            IIAPI_TRACE( IIAPI_TR_ERROR )
                ( "%s: transaction commit failed\n", sql_tran_sm.sm_id );

	    if ( ! IIapi_localError( sm_hndl, E_AP000B_COMMIT_FAILED, 
				     II_SS40001_SERIALIZATION_FAIL,
				     IIAPI_ST_FAILURE ) )
	    {
	        status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
	    }
	    break;

	case SQL_TA_ERPC :
	    /*
	    ** Prepare-to-commit failed.
	    */
            IIAPI_TRACE( IIAPI_TR_ERROR )
                ( "%s: transaction prepare failed\n", sql_tran_sm.sm_id );

	    if ( ! IIapi_localError( sm_hndl, E_AP000C_2PC_REFUSED, 
				     II_SS40001_SERIALIZATION_FAIL,
				     IIAPI_ST_FAILURE ) )
	    {
	        status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
	    }
	    break;

	case SQL_TA_RRSP :
	{
	    /*
	    ** Read response message.
	    */
	    IIAPI_MSG_BUFF	*msgBuff = (IIAPI_MSG_BUFF *)parmBlock;
	    GCA_RE_DATA		respData;

	    if ( (status = IIapi_readMsgResponse( msgBuff, &respData, TRUE ))
							!= IIAPI_ST_SUCCESS )
	    {
		success = FALSE;
		break;
	    }

	    /*
	    ** Check for XA error
	    */
	    if ( 
	         respData.gca_rqstatus & GCA_XA_ERROR_MASK  &&
	         respData.gca_errd5  &&
	         ! IIapi_xaError( sm_hndl, respData.gca_errd5 ) 
	       )
	    {
	    	status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
	    break;
	}
	case SQL_TA_RXAR :
	{
	    /*
	    ** Read XA response message.
	    */
	    IIAPI_MSG_BUFF	*msgBuff = (IIAPI_MSG_BUFF *)parmBlock;
	    GCA_RE_DATA		respData;

	    if ( (status = IIapi_readMsgResponse( msgBuff, &respData, TRUE ))
							!= IIAPI_ST_SUCCESS )
	    {
		success = FALSE;
		break;
	    }

	    /*
	    ** If no XA error is returned, generate generic XA error.
	    */
	    if ( ! (respData.gca_rqstatus & GCA_XA_ERROR_MASK)  ||
	         ! respData.gca_errd5 )  
		respData.gca_errd5 = IIAPI_XAER_RMERR;

	    if ( ! IIapi_xaError( sm_hndl, respData.gca_errd5 ) )
	    {
	    	status = IIAPI_ST_OUT_OF_MEMORY;
		success = FALSE;
		break;
	    }
	    break;
	}
	case SQL_TA_CBOK :
	    /*
	    ** Callback with success.  Note that
	    ** this will pick up the most severe
	    ** status from the errors associated
	    ** with the event handle.
	    */
	    if ( tranHndl->th_callback )
	    {
		IIapi_appCallback(tranHndl->th_parm, sm_hndl, IIAPI_ST_SUCCESS);
		tranHndl->th_callback = FALSE;
	    }
	    break;

	case SQL_TA_CBFL :
	    /*
	    ** Callback with failure.
	    */
	    if ( tranHndl->th_callback )
	    {
		IIapi_appCallback(tranHndl->th_parm, sm_hndl, IIAPI_ST_FAILURE);
		tranHndl->th_callback = FALSE;
	    }
	    break;

	case SQL_TA_CBIF :
	    /*
	    ** API function called in wrong state.
	    */
	    if ( ! IIapi_localError( sm_hndl, E_AP0006_INVALID_SEQUENCE, 
				     II_SS5000R_RUN_TIME_LOGICAL_ERROR,
				     IIAPI_ST_FAILURE ) )
		status = IIAPI_ST_OUT_OF_MEMORY;
	    else
		status = IIAPI_ST_FAILURE;

            /*
            ** This may not have been a transaction
            ** related function, and we may have a
            ** callback saved on the transaction
            ** handle, so we carefully make the
            ** callback to the caller making sure
            ** not to disturb the transaction handle.
            */
            IIapi_appCallback( (IIAPI_GENPARM *)parmBlock, sm_hndl, status );
	    break;

	case SQL_TA_CBAB :
	    /*
	    ** Callback with transaction abort.
	    */
	    if ( tranHndl->th_callback )
	    {
		if ( ! IIapi_localError( sm_hndl, E_AP0002_TRANSACTION_ABORTED, 
					 II_SS40001_SERIALIZATION_FAIL,
					 IIAPI_ST_FAILURE ) )
		    status = IIAPI_ST_OUT_OF_MEMORY;
		else
		    status = IIAPI_ST_FAILURE;

		IIapi_appCallback( tranHndl->th_parm, sm_hndl, status );
		tranHndl->th_callback = FALSE;
	    }
	    break;

	case SQL_TA_CBABX :
	    /*
	    ** Callback with XA transaction abort.
	    */
	    if ( tranHndl->th_callback )
	    {
		if ( ! IIapi_xaError( sm_hndl, IIAPI_XA_RBROLLBACK ) )
		    status = IIAPI_ST_OUT_OF_MEMORY;
		else
		    status = IIAPI_ST_FAILURE;

		IIapi_appCallback( tranHndl->th_parm, sm_hndl, status );
		tranHndl->th_callback = FALSE;
	    }
	    break;

	case SQL_TA_RCVE :
	    /*
	    ** Receive error.  
	    **
	    ** We have received an invalid message.  
	    ** Since the connection state machine 
	    ** may ignore this particular message
	    ** type, convert to a type which will
	    ** ensure the proper handling in all
	    ** state machines.
	    */
	    IIapi_liDispatch( IIAPI_EV_UNEXPECTED_RCVD, sm_hndl, NULL, NULL );
	    break;

	case SQL_TA_HALT :
	    /*
	    ** Halt state machine execution.
	    */
    	    return( FALSE );
    }

    /*
    ** If we couldn't complete the action, callback with failure.
    */
    if ( ! success  &&  tranHndl->th_callback )
    {
        IIapi_appCallback( tranHndl->th_parm, sm_hndl, status );
        tranHndl->th_callback = FALSE;
    }

    return( success );
}
Example #7
0
static II_BOOL
sm_execute
(
    IIAPI_ACTION        action,
    IIAPI_HNDL          *ev_hndl,
    IIAPI_HNDL          *sm_hndl,
    II_PTR              parmBlock
)
{
    IIAPI_TRANHNDL      *tranHndl = (IIAPI_TRANHNDL *)sm_hndl;
    IIAPI_SAVEPTHNDL	*savePtHndl;
    IIAPI_SAVEPTPARM    *savePtParm;
    IIAPI_STATUS        status = OK;
    II_BOOL             success = TRUE;
    char		queryText[ 64 ];

    switch( action )
    {
        case NS_TA_REMC :
	    /*
	    ** Remember callback.
	    */
	    tranHndl->th_callback = TRUE;
	    tranHndl->th_parm = (IIAPI_GENPARM *)parmBlock;
	    break;

	case NS_TA_DELH :
	    /*
	    ** Mark handle for deletion.
	    */
	    QUremove( (QUEUE *)tranHndl );
	    sm_hndl->hd_delete = TRUE;
	    break;

	case NS_TA_CBOK :
	    /*
	    ** Callback with success.  Note that
	    ** this will pick up the most severe
	    ** status from the errors associated
	    ** with the event handle.
	    */
	    if ( tranHndl->th_callback )
	    {
		IIapi_appCallback(tranHndl->th_parm, sm_hndl, IIAPI_ST_SUCCESS);
		tranHndl->th_callback = FALSE;
	    }
	    break;

	case NS_TA_CBIF :
	    /*
	    ** API function called in wrong state.
	    */
	    if ( ! IIapi_localError( sm_hndl, E_AP0006_INVALID_SEQUENCE, 
				     II_SS5000R_RUN_TIME_LOGICAL_ERROR,
				     IIAPI_ST_FAILURE ) )
		status = IIAPI_ST_OUT_OF_MEMORY;
	    else
		status = IIAPI_ST_FAILURE;

            /*
            ** This may not have been a transaction
            ** related function, and we may have a
            ** callback saved on the transaction
            ** handle, so we carefully make the
            ** callback to the caller making sure
            ** not to disturb the transaction handle.
            */
            IIapi_appCallback( (IIAPI_GENPARM *)parmBlock, sm_hndl, status );

            /*
            ** We must return the failure here rather
            ** than following the normal exit route
            ** to ensure that the transaction handle
            ** callback does not get made.
            */
            return( FALSE );

	case NS_TA_RCVE :
	    /*
	    ** Receive error.  
	    **
	    ** We have received an invalid message.  
	    ** Since the connection state machine 
	    ** may ignore this particular message
	    ** type, convert to a type which will
	    ** ensure the proper handling in all
	    ** state machines.
	    */
	    IIapi_liDispatch( IIAPI_EV_UNEXPECTED_RCVD, sm_hndl, NULL, NULL );
	    return( FALSE );
    }

    /*
    ** If we couldn't complete the action, callback with failure.
    */
    if ( ! success  &&  tranHndl->th_callback )
    {
        IIapi_appCallback( tranHndl->th_parm, sm_hndl, status );
        tranHndl->th_callback = FALSE;
    }

    return( success );
}
Example #8
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_batch( IIAPI_BATCHPARM II_FAR *batchParm )
{
    IIAPI_CONNHNDL	*connHndl;
    IIAPI_TRANHNDL	*tranHndl;
    IIAPI_STMTHNDL	*stmtHndl;
    IIAPI_HNDL		*handle;
    
    IIAPI_TRACE( IIAPI_TR_TRACE )( "IIapi_batch: adding a batch query\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! batchParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: null batch parameters\n" );
	return;
    }
    
    batchParm->ba_genParm.gp_completed = FALSE;
    batchParm->ba_genParm.gp_status = IIAPI_ST_SUCCESS;
    batchParm->ba_genParm.gp_errorHandle = NULL;
    connHndl = (IIAPI_CONNHNDL *)batchParm->ba_connHandle;
    handle = (IIAPI_HNDL *)batchParm->ba_tranHandle;
    stmtHndl = (IIAPI_STMTHNDL *)batchParm->ba_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: API is not initialized\n" );
	IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			   IIAPI_ST_NOT_INITIALIZED );
	return;
    }
    
    /*
    ** Validate connection handle.
    */
    if ( ! IIapi_isConnHndl( connHndl )  ||  IIAPI_STALE_HANDLE( connHndl ) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: invalid connHndl %p\n", connHndl );
	IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    /*
    ** Validate transaction handle.
    */
    if ( handle  &&  ! IIapi_isTranName( (IIAPI_TRANNAME *)handle )  &&
                    (! IIapi_isTranHndl( (IIAPI_TRANHNDL *)handle )  ||
	             IIAPI_STALE_HANDLE( handle )) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: invalid tranHndl %p\n", handle );
	IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }

    /*
    ** Validate statement handle.
    */
    if ( stmtHndl )
    {
    	if ( ! IIapi_isStmtHndl( (IIAPI_STMTHNDL *)stmtHndl )  ||
	     IIAPI_STALE_HANDLE( stmtHndl ) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_batch: invalid stmtHndl %p\n", stmtHndl );
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_INVALID_HANDLE );
	    return;
	}

	if ( ! handle  ||  IIapi_isTranName( (IIAPI_TRANNAME *)handle) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_batch: transaction handle required\n" );
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_INVALID_HANDLE );
	    return;
	}

    	if ( handle != (IIAPI_HNDL *)stmtHndl->sh_tranHndl )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_batch: wrong tranHndl %p for stmtHndl %p\n",
		  handle, stmtHndl );
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_INVALID_HANDLE );
	    return;
	}

	if ( connHndl != IIapi_getConnHndl( (IIAPI_HNDL *)stmtHndl ) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_batch: wrong connHndl %p for stmtHndl %p\n",
		  connHndl, stmtHndl );
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_INVALID_HANDLE );
	    return;
	}
    }

    IIAPI_TRACE( IIAPI_TR_INFO )
	( "IIapi_batch: connHndl = %p, tranHndl = %p, stmtHndl = %p, queryType = %d\n",
	  batchParm->ba_connHandle, batchParm->ba_tranHandle,
	  batchParm->ba_stmtHandle, batchParm->ba_queryType );
    
    IIAPI_TRACE( IIAPI_TR_INFO )
	( "IIapi_batch: queryText = %s\n",
	  batchParm->ba_queryText ? batchParm->ba_queryText : "<NULL>" );
    
    IIapi_clearAllErrors( stmtHndl ? (IIAPI_HNDL *)stmtHndl :
	( (handle && IIapi_isTranHndl( (IIAPI_TRANHNDL *)handle ))
	  ? handle : (IIAPI_HNDL *)connHndl ) );
    
    /*
    ** Check that batch processing is supported on the connection.
    */
    if ( connHndl->ch_partnerProtocol < GCA_PROTOCOL_LEVEL_68 )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: batch not supported at protocol level %d\n", 
	      connHndl->ch_partnerProtocol );

	if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				 E_AP001F_BATCH_UNSUPPORTED, 
				 II_SS50008_UNSUPPORTED_STMT,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &batchParm->ba_genParm, 
			       (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	return;
    }

    /*
    ** Check restrictions on query type and associated info.
    */
    if ( connHndl->ch_type != IIAPI_SMT_SQL  ||
	 (batchParm->ba_queryType != IIAPI_QT_QUERY  &&
	  batchParm->ba_queryType != IIAPI_QT_EXEC   &&
	  batchParm->ba_queryType != IIAPI_QT_EXEC_PROCEDURE) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: invalid query type %d for connection type %d\n", 
	      batchParm->ba_queryType, connHndl->ch_type );

	if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				 E_AP0011_INVALID_PARAM_VALUE, 
				 II_SS50008_UNSUPPORTED_STMT,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &batchParm->ba_genParm, 
			       (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	return;
    }

    if ( batchParm->ba_queryType != IIAPI_QT_EXEC_PROCEDURE  &&
         ! batchParm->ba_queryText )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: query requires query text\n" );

	if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				 E_AP0011_INVALID_PARAM_VALUE, 
				 II_SS5000R_RUN_TIME_LOGICAL_ERROR,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &batchParm->ba_genParm, 
			       (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	return;
    }

    if ( batchParm->ba_queryType == IIAPI_QT_EXEC_PROCEDURE  &&
         ! batchParm->ba_parameters )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: query requires parameters, none indicated\n" );

	if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				 E_AP0011_INVALID_PARAM_VALUE, 
				 II_SS5000R_RUN_TIME_LOGICAL_ERROR,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &batchParm->ba_genParm, 
			       (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	return;
    }

    /*
    ** Allocate a transaction handle if one was not provided.
    */
    if ( ! handle  ||  IIapi_isTranName( (IIAPI_TRANNAME *)handle ) )
    {
	/*
	** Check to see if there is an active transaction.
	*/
	if ( ! IIapi_isQueEmpty( (QUEUE *)&connHndl->ch_tranHndlList ) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		("IIapi_batch: connection has active transaction.\n");

	    if ( ! IIapi_localError( (IIAPI_HNDL *)connHndl, 
				     E_AP0003_ACTIVE_TRANSACTIONS, 
				     II_SS25000_INV_XACT_STATE,
				     IIAPI_ST_FAILURE ) )
		IIapi_appCallback( &batchParm->ba_genParm, NULL, 
				   IIAPI_ST_OUT_OF_MEMORY );
	    else
		IIapi_appCallback( &batchParm->ba_genParm, 
				   (IIAPI_HNDL *)connHndl, IIAPI_ST_FAILURE );
	    return;
	}

	if ( ! ( tranHndl = IIapi_createTranHndl(
				(IIAPI_TRANNAME *)batchParm->ba_tranHandle,
				(IIAPI_CONNHNDL *)batchParm->ba_connHandle ) ) )
	{
	    IIAPI_TRACE( IIAPI_TR_ERROR )
		( "IIapi_batch: createTranHndl failed\n" );
	    IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	    return;
	}
    }
    else
    {
	/*
	** Use existing transaction handle.
	*/
	tranHndl = (IIAPI_TRANHNDL *)handle;
	IIapi_clearAllErrors( (IIAPI_HNDL *)tranHndl );
    }
    
    /*
    ** Allocate a new statement handle or initialize existing handle.
    */
    if ( stmtHndl )
	initStmtHndl( stmtHndl );
    else  if ( ! (stmtHndl = IIapi_createStmtHndl( connHndl, tranHndl )) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_batch: createStmtHndl failed\n" );

	IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			   IIAPI_ST_OUT_OF_MEMORY );
	goto freeTranHandle;
    }

    /*
    ** Update statement handle with batch query information.
    */
    if ( batchParm->ba_queryText  &&
	 ! (stmtHndl->sh_queryText = STalloc( batchParm->ba_queryText )) )
    {
	IIAPI_TRACE( IIAPI_TR_FATAL )
	    ( "IIapi_batch: can't alloc query text\n" );

	IIapi_appCallback( &batchParm->ba_genParm, NULL, 
			   IIAPI_ST_OUT_OF_MEMORY );
	goto freeStmtHandle;
    }
    
    stmtHndl->sh_queryType = batchParm->ba_queryType;
    if ( batchParm->ba_parameters )  stmtHndl->sh_flags |= IIAPI_SH_PARAMETERS;

    /*
    ** The current set of external batch/query flags
    ** are not applicable to batch processing, but
    ** we pass them along anyway.
    */
    stmtHndl->sh_flags |= batchParm->ba_flags & IIAPI_QF_ALL_FLAGS;

    batchParm->ba_stmtHandle = (II_PTR)stmtHndl;
    batchParm->ba_tranHandle = (II_PTR)tranHndl;
    
    IIapi_uiDispatch( IIAPI_EV_BATCH_FUNC, 
		      (IIAPI_HNDL *)stmtHndl, (II_PTR)batchParm );
    return;

  freeStmtHandle:

    /*
    ** If the statement handle is not the input handle,
    ** then we allocated a new handle above and we must
    ** now delete it.
    */
    if ( stmtHndl != (IIAPI_STMTHNDL *)batchParm->ba_stmtHandle )
	IIapi_deleteStmtHndl( stmtHndl );

  freeTranHandle:

    /*
    ** If the transaction handle is not the input handle,
    ** then we allocated a new handle above and we must
    ** now delete it.
    */
    if ( tranHndl != (IIAPI_TRANHNDL *)batchParm->ba_tranHandle )
	IIapi_deleteTranHndl( tranHndl );

    return;
}
Example #9
0
II_EXTERN II_VOID II_FAR II_EXPORT
IIapi_putColumns( IIAPI_PUTCOLPARM II_FAR *putColParm )
{
    IIAPI_STMTHNDL	*stmtHndl;
    II_ULONG		err_code;
    
    IIAPI_TRACE( IIAPI_TR_TRACE ) 
	( "IIapi_putColumns: sending tuple to server\n" );
    
    /*
    ** Validate Input parameters
    */
    if ( ! putColParm )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_putColumns: null putColumns parameters\n" );
	return;
    }
    
    putColParm->pc_genParm.gp_completed = FALSE;
    putColParm->pc_genParm.gp_status = IIAPI_ST_SUCCESS;
    putColParm->pc_genParm.gp_errorHandle = NULL;
    stmtHndl = (IIAPI_STMTHNDL *)putColParm->pc_stmtHandle;
    
    /*
    ** Make sure API is initialized
    */
    if ( ! IIapi_initialized() )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_putColumns: API is not initialized\n" );
	IIapi_appCallback( &putColParm->pc_genParm, NULL, 
			   IIAPI_ST_NOT_INITIALIZED );
	return;
    }

    if ( ! IIapi_isStmtHndl( stmtHndl )  ||  IIAPI_STALE_HANDLE( stmtHndl ) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_putColumns: invalid statement handle\n" );
	IIapi_appCallback( &putColParm->pc_genParm, NULL, 
			   IIAPI_ST_INVALID_HANDLE );
	return;
    }
    
    IIAPI_TRACE( IIAPI_TR_INFO ) 
	( "IIapi_putColumns: stmtHndl = %p\n", stmtHndl );
    
    IIapi_clearAllErrors( (IIAPI_HNDL *)stmtHndl );
    
    if ( ! IIapi_validPColCount( stmtHndl, putColParm ) )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ("IIapi_putColumns: invalid count: %d (actual %d, index %d)\n",
	     (II_LONG)putColParm->pc_columnCount, 
	     (II_LONG)stmtHndl->sh_colCount,
	     (II_LONG)stmtHndl->sh_colIndex );

	if ( ! IIapi_localError( (IIAPI_HNDL *)stmtHndl, 
				 E_AP0010_INVALID_COLUMN_COUNT, 
				 II_SS21000_CARD_VIOLATION,
				 IIAPI_ST_FAILURE ) )
	    IIapi_appCallback( &putColParm->pc_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	else
	    IIapi_appCallback( &putColParm->pc_genParm, 
			       (IIAPI_HNDL *)stmtHndl, IIAPI_ST_FAILURE );
	return;
    }
    
    if ( (err_code = IIapi_validDataValue( putColParm->pc_columnCount, 
    					   &stmtHndl->sh_colDescriptor[ 
						stmtHndl->sh_colIndex ],
					   putColParm->pc_columnData )) != OK )
    {
	IIAPI_TRACE( IIAPI_TR_ERROR )
	    ( "IIapi_putColumns: column data conflicts with descriptor\n" );

	/*
	** We only issue a warning on data conflicts, but if the
	** warning can't be generated then abort the operation.
	*/
	if ( ! IIapi_localError( (IIAPI_HNDL *)stmtHndl, err_code, 
				 II_SS22500_INVALID_DATA_TYPE,
				 IIAPI_ST_WARNING ) )
	{
	    IIapi_appCallback( &putColParm->pc_genParm, NULL, 
			       IIAPI_ST_OUT_OF_MEMORY );
	    return;
    	}
    }
    
    stmtHndl->sh_colFetch = putColParm->pc_columnCount;

    IIapi_uiDispatch( IIAPI_EV_PUTCOLUMN_FUNC, 
		      (IIAPI_HNDL *)stmtHndl, (II_PTR)putColParm );

    return;
}