static SQLRETURN extract_sql_error_rec_w( EHEAD *head,
SQLWCHAR *sqlstate,
SQLINTEGER rec_number,
SQLINTEGER *native_error,
SQLWCHAR *message_text,
SQLSMALLINT buffer_length,
SQLSMALLINT *text_length )
{
SQLRETURN ret;
if ( sqlstate )
{
SQLWCHAR *tmp;
tmp = ansi_to_unicode_alloc((SQLCHAR*) "00000", SQL_NTS, __get_connection( head ), NULL );
wide_strcpy( sqlstate, tmp );
free( tmp );
}
if ( rec_number <= head -> sql_diag_head.internal_count )
{
ERROR *ptr;
ptr = head -> sql_diag_head.internal_list_head;
while( rec_number > 1 )
{
ptr = ptr -> next;
rec_number --;
}
if ( !ptr )
{
return SQL_NO_DATA;
}
if ( sqlstate )
{
wide_strcpy( sqlstate, ptr -> sqlstate );
}
if ( buffer_length < wide_strlen( ptr -> msg ) + 1 )
{
ret = SQL_SUCCESS_WITH_INFO;
}
else
{
ret = SQL_SUCCESS;
}
if ( message_text )
{
if ( ret == SQL_SUCCESS )
{
wide_strcpy( message_text, ptr -> msg );
}
else
{
memcpy( message_text, ptr -> msg, buffer_length * 2 );
message_text[ buffer_length - 1 ] = '\0';
}
}
if ( text_length )
{
*text_length = wide_strlen( ptr -> msg );
}
if ( native_error )
{
*native_error = ptr -> native_error;
}
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
__map_error_state((char*) sqlstate, __get_version( head ));
return ret;
}
else if ( rec_number <= head -> sql_diag_head.internal_count +
head -> sql_diag_head.error_count )
{
ERROR *ptr;
rec_number -= head -> sql_diag_head.internal_count;
if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGRECW( __get_connection( head )))
{
ret = SQLGETDIAGRECW( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
{
__map_error_state_w( sqlstate, __get_version( head ));
}
return ret;
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGREC( __get_connection( head )))
{
SQLCHAR *as1 = NULL, *as2 = NULL;
if ( sqlstate )
{
as1 = malloc( 7 );
}
if ( message_text && buffer_length > 0 )
{
as2 = malloc( buffer_length + 1 );
}
ret = SQLGETDIAGREC( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
as1 ? as1 : (SQLCHAR *)sqlstate,
native_error,
as2 ? as2 : (SQLCHAR *)message_text,
buffer_length,
text_length );
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
{
if ( sqlstate )
{
if ( as1 )
{
ansi_to_unicode_copy( sqlstate,(char*) as1, SQL_NTS, __get_connection( head ), NULL );
__map_error_state_w( sqlstate, __get_version( head ));
}
}
if ( message_text )
{
if ( as2 )
{
ansi_to_unicode_copy( message_text,(char*) as2, SQL_NTS, __get_connection( head ), NULL );
}
}
}
if ( as1 ) free( as1 );
if ( as2 ) free( as2 );
return ret;
}
else
{
ptr = head -> sql_diag_head.error_list_head;
while( rec_number > 1 )
{
ptr = ptr -> next;
rec_number --;
}
if ( !ptr )
{
return SQL_NO_DATA;
}
if ( sqlstate )
{
wide_strcpy( sqlstate, ptr -> sqlstate );
}
if ( buffer_length < wide_strlen( ptr -> msg ) + 1 )
{
ret = SQL_SUCCESS_WITH_INFO;
}
else
{
ret = SQL_SUCCESS;
}
if ( message_text )
{
if ( ret == SQL_SUCCESS )
{
wide_strcpy( message_text, ptr -> msg );
}
else
{
memcpy( message_text, ptr -> msg, buffer_length * 2 );
message_text[ buffer_length - 1 ] = '\0';
}
}
if ( text_length )
{
*text_length = wide_strlen( ptr -> msg );
}
if ( native_error )
{
*native_error = ptr -> native_error;
}
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
__map_error_state_w( sqlstate, __get_version( head ));
return ret;
}
}
else
{
return SQL_NO_DATA;
}
}
static SQLRETURN extract_sql_error_rec( EHEAD *head,
SQLCHAR *sqlstate,
SQLINTEGER rec_number,
SQLINTEGER *native_error,
SQLCHAR *message_text,
SQLSMALLINT buffer_length,
SQLSMALLINT *text_length )
{
SQLRETURN ret;
if ( sqlstate )
strcpy((char*) sqlstate, "00000" );
if ( rec_number <= head -> sql_diag_head.internal_count )
{
ERROR *ptr;
SQLCHAR *as1 = NULL;
ptr = head -> sql_diag_head.internal_list_head;
while( rec_number > 1 )
{
ptr = ptr -> next;
rec_number --;
}
as1 = (SQLCHAR*) unicode_to_ansi_alloc( ptr -> msg, SQL_NTS, __get_connection( head ));
if ( sqlstate )
{
unicode_to_ansi_copy((char*) sqlstate, ptr -> sqlstate, SQL_NTS, __get_connection( head ));
}
if ( buffer_length < strlen((char*) as1 ) + 1 )
{
ret = SQL_SUCCESS_WITH_INFO;
}
else
{
ret = SQL_SUCCESS;
}
if ( message_text && as1 )
{
if ( ret == SQL_SUCCESS )
{
strcpy((char*) message_text, (char*) as1 );
}
else
{
memcpy( message_text, as1, buffer_length );
message_text[ buffer_length - 1 ] = '\0';
}
}
if ( text_length && as1 )
{
*text_length = strlen((char*) as1 );
}
if ( native_error )
{
*native_error = ptr -> native_error;
}
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
__map_error_state( (char*) sqlstate, __get_version( head ));
if ( as1 )
{
free( as1 );
}
return ret;
}
else if ( !__is_env( head ) && __get_connection( head ) -> state != STATE_C2 )
{
ERROR *ptr;
SQLCHAR *as1 = NULL;
SQLWCHAR *s1 = NULL, *s2 = NULL;
if ( rec_number <= head -> sql_diag_head.internal_count +
head -> sql_diag_head.error_count )
{
rec_number -= head -> sql_diag_head.internal_count;
}
else
{
rec_number -= ( head -> sql_diag_head.internal_count + head -> sql_diag_head.error_count );
}
s1 = malloc( sizeof( SQLWCHAR ) * ( 6 + 1 ));
if ( buffer_length > 0 )
{
s2 = malloc( sizeof( SQLWCHAR ) * ( buffer_length + 1 ));
}
if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGRECW( __get_connection( head )))
{
ret = SQLGETDIAGRECW( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
s1,
native_error,
s2,
buffer_length,
text_length );
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
{
if ( sqlstate )
{
unicode_to_ansi_copy((char*) sqlstate, s1, SQL_NTS, __get_connection( head ));
__map_error_state((char*) sqlstate, __get_version( head ));
}
if ( message_text )
{
unicode_to_ansi_copy((char*) message_text, s2, SQL_NTS, __get_connection( head ));
}
}
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGREC( __get_connection( head )))
{
ret = SQLGETDIAGREC( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
__map_error_state((char*) sqlstate, __get_version( head ));
}
else
{
SQLCHAR *as1 = NULL;
ptr = head -> sql_diag_head.error_list_head;
while( rec_number > 1 )
{
ptr = ptr -> next;
rec_number --;
}
as1 = (SQLCHAR*) unicode_to_ansi_alloc( ptr -> msg, SQL_NTS, __get_connection( head ));
if ( sqlstate )
{
unicode_to_ansi_copy((char*) sqlstate, ptr -> sqlstate, SQL_NTS, __get_connection( head ));
}
if ( as1 && buffer_length < strlen((char*) as1 ) + 1 )
{
ret = SQL_SUCCESS_WITH_INFO;
}
else
{
ret = SQL_SUCCESS;
}
if ( message_text && as1 )
{
if ( ret == SQL_SUCCESS )
{
strcpy((char*) message_text,(char*) as1 );
}
else
{
memcpy( message_text, as1, buffer_length );
message_text[ buffer_length - 1 ] = '\0';
}
}
if ( text_length && as1 )
{
*text_length = strlen((char*) as1 );
}
if ( native_error )
{
*native_error = ptr -> native_error;
}
/*
* map 3 to 2 if required
*/
if ( SQL_SUCCEEDED( ret ) && sqlstate )
__map_error_state((char*) sqlstate, __get_version( head ));
if ( as1 )
{
free( as1 );
}
}
if ( s1 )
free( s1 );
if ( s2 )
free( s2 );
return ret;
}
else
{
return SQL_NO_DATA;
}
}
SQLRETURN CLError( SQLHENV environment_handle,
SQLHDBC connection_handle,
SQLHSTMT statement_handle,
SQLCHAR *sqlstate,
SQLINTEGER *native_error,
SQLCHAR *message_text,
SQLSMALLINT buffer_length,
SQLSMALLINT *text_length )
{
if ( statement_handle )
{
CLHSTMT cl_statement = (CLHSTMT) statement_handle;
if ( cl_statement -> driver_stmt_closed )
{
return SQL_NO_DATA;
}
if ( CHECK_SQLERROR( cl_statement -> cl_connection ))
{
return SQLERROR( cl_statement -> cl_connection,
SQL_NULL_HENV,
SQL_NULL_HDBC,
cl_statement -> driver_stmt,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
}
else
{
SQLRETURN ret;
ret = SQLGETDIAGREC( cl_statement -> cl_connection,
SQL_HANDLE_STMT,
cl_statement -> driver_stmt,
cl_statement -> error_count,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
if ( SQL_SUCCEEDED( ret ))
{
cl_statement -> error_count ++;
}
else
{
cl_statement -> error_count = 0;
}
return ret;
}
}
else if ( connection_handle )
{
CLHDBC cl_connection = (CLHDBC) connection_handle;
if ( CHECK_SQLERROR( cl_connection ))
{
return SQLERROR( cl_connection,
SQL_NULL_HENV,
cl_connection -> driver_dbc,
SQL_NULL_HSTMT,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
}
else
{
SQLRETURN ret;
ret = SQLGETDIAGREC( cl_connection,
SQL_HANDLE_DBC,
cl_connection -> driver_dbc,
cl_connection -> error_count,
sqlstate,
native_error,
message_text,
buffer_length,
text_length );
if ( SQL_SUCCEEDED( ret ))
{
cl_connection -> error_count ++;
}
else
{
cl_connection -> error_count = 0;
}
return ret;
}
}
else if ( environment_handle )
{
/*
* shouldn't get here
*/
return SQL_NO_DATA;
}
}