SQLRETURN SQLPrepareW( SQLHSTMT statement_handle,
SQLWCHAR *statement_text,
SQLINTEGER text_length )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR *s1;
SQLCHAR s2[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
/*
* allocate some space for the buffer
*/
if ( statement_text && text_length == SQL_NTS )
{
s1 = malloc( wide_strlen( statement_text ) + 100 );
}
else if ( statement_text )
{
s1 = malloc( text_length + 100 );
}
else
{
s1 = malloc( 101 );
}
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tSQL = %s",
statement,
__wstring_with_length( s1, statement_text, text_length ));
free( s1 );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
thread_protect( SQL_HANDLE_STMT, statement );
if ( !statement_text )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &statement -> error,
ERROR_HY009, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( text_length <= 0 && text_length != SQL_NTS )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY090" );
__post_internal_error( &statement -> error,
ERROR_HY090, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
/*
* check states
*/
#ifdef NR_PROBE
if ( statement -> state == STATE_S5 ||
statement -> state == STATE_S6 ||
statement -> state == STATE_S7 )
#else
if ( statement -> state == STATE_S6 ||
statement -> state == STATE_S7 )
#endif
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: 24000" );
__post_internal_error( &statement -> error,
ERROR_24000, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &statement -> error,
ERROR_HY010, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
if ( statement -> interupted_func != SQL_API_SQLPREPARE )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &statement -> error,
ERROR_HY010, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
}
if ( statement -> connection -> unicode_driver )
{
if ( !CHECK_SQLPREPAREW( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
ret = SQLPREPAREW( statement -> connection ,
statement -> driver_stmt,
statement_text,
text_length );
}
else
{
SQLCHAR *as1;
if ( !CHECK_SQLPREPARE( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
as1 = (SQLCHAR*) unicode_to_ansi_alloc( statement_text, text_length, statement -> connection );
ret = SQLPREPARE( statement -> connection ,
statement -> driver_stmt,
as1,
text_length );
if ( as1 ) free( as1 );
}
if ( SQL_SUCCEEDED( ret ))
{
statement -> hascols = 0;
statement -> state = STATE_S3;
statement -> prepared = 1;
}
else if ( ret == SQL_STILL_EXECUTING )
{
statement -> interupted_func = SQL_API_SQLPREPARE;
if ( statement -> state != STATE_S11 &&
statement -> state != STATE_S12 )
statement -> state = STATE_S11;
}
else
{
statement -> state = STATE_S1;
}
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tExit:[%s]",
__get_return_status( ret, s2 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
return function_return( SQL_HANDLE_STMT, statement, ret );
}
static SQLRETURN extract_sql_error_field( EHEAD *head,
SQLSMALLINT rec_number,
SQLSMALLINT diag_identifier,
SQLPOINTER diag_info_ptr,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length_ptr )
{
ERROR *ptr;
/*
* check the header fields first
*/
switch( diag_identifier )
{
case SQL_DIAG_CURSOR_ROW_COUNT:
case SQL_DIAG_ROW_COUNT:
{
SQLLEN val;
SQLRETURN ret;
if ( head -> handle_type != SQL_HANDLE_STMT )
{
return SQL_ERROR;
}
else if ( head -> header_set )
{
switch( diag_identifier )
{
case SQL_DIAG_CURSOR_ROW_COUNT:
if ( SQL_SUCCEEDED( head -> diag_cursor_row_count_ret ) && diag_info_ptr )
{
*((SQLLEN*)diag_info_ptr) = head -> diag_cursor_row_count;
}
return head -> diag_cursor_row_count_ret;
case SQL_DIAG_ROW_COUNT:
if ( SQL_SUCCEEDED( head -> diag_row_count_ret ) && diag_info_ptr )
{
*((SQLLEN*)diag_info_ptr) = head -> diag_row_count;
}
return head -> diag_row_count_ret;
}
}
else if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELDW( __get_connection( head )))
{
ret = SQLGETDIAGFIELDW( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
return ret;
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELD( __get_connection( head )))
{
ret = SQLGETDIAGFIELD( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
return ret;
}
else if ( CHECK_SQLROWCOUNT( __get_connection( head )))
{
ret = DEF_SQLROWCOUNT( __get_connection( head ),
__get_driver_handle( head ),
&val );
if ( !SQL_SUCCEEDED( ret ))
{
return ret;
}
}
else
{
val = 0;
}
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &val, sizeof( val ));
}
}
return SQL_SUCCESS;
case SQL_DIAG_DYNAMIC_FUNCTION:
{
SQLRETURN ret;
if ( head -> handle_type != SQL_HANDLE_STMT )
{
return SQL_ERROR;
}
else if ( head -> header_set )
{
if ( SQL_SUCCEEDED( head -> diag_dynamic_function_ret ) && diag_info_ptr )
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, head -> diag_dynamic_function, buffer_length, __get_connection( head ));
if ( string_length_ptr )
{
*string_length_ptr = wide_strlen( head -> diag_dynamic_function );
}
}
return head -> diag_dynamic_function_ret;
}
else if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELDW( __get_connection( head )))
{
SQLWCHAR *s1 = NULL;
if ( buffer_length > 0 )
{
s1 = malloc( sizeof( SQLWCHAR ) * ( buffer_length + 1 ));
}
ret = SQLGETDIAGFIELDW( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
s1 ? s1 : diag_info_ptr,
buffer_length,
string_length_ptr );
if ( SQL_SUCCEEDED( ret ) && diag_info_ptr && s1 )
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, s1, buffer_length, __get_connection( head ));
}
if ( s1 )
{
free( s1 );
}
return ret;
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELD( __get_connection( head )))
{
ret = SQLGETDIAGFIELD( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
return ret;
}
if ( diag_info_ptr )
{
strcpy( diag_info_ptr, "" );
}
}
return SQL_SUCCESS;
case SQL_DIAG_DYNAMIC_FUNCTION_CODE:
{
SQLINTEGER val;
SQLRETURN ret;
if ( head -> handle_type != SQL_HANDLE_STMT )
{
return SQL_ERROR;
}
else if ( head -> header_set )
{
if ( SQL_SUCCEEDED( head -> diag_dynamic_function_code_ret ) && diag_info_ptr )
{
*((SQLINTEGER*)diag_info_ptr) = head -> diag_dynamic_function_code;
}
return head -> diag_dynamic_function_code_ret;
}
else if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELDW( __get_connection( head )))
{
ret = SQLGETDIAGFIELDW( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
return ret;
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELD( __get_connection( head )))
{
ret = SQLGETDIAGFIELD( __get_connection( head ),
SQL_HANDLE_STMT,
__get_driver_handle( head ),
0,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
return ret;
}
else
{
val = SQL_DIAG_UNKNOWN_STATEMENT;
}
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &val, sizeof( val ));
}
}
return SQL_SUCCESS;
case SQL_DIAG_NUMBER:
{
SQLINTEGER val;
val = head -> sql_diag_head.internal_count +
head -> sql_diag_head.error_count;
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &val, sizeof( val ));
}
}
return SQL_SUCCESS;
case SQL_DIAG_RETURNCODE:
{
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &head -> return_code,
sizeof( head -> return_code ));
}
}
return SQL_SUCCESS;
}
/*
* else check the records
*/
if ( rec_number < 1 )
{
return SQL_ERROR;
}
if ( rec_number <= head -> sql_diag_head.internal_count )
{
/*
* local errors
*/
ptr = head -> sql_diag_head.internal_list_head;
while( rec_number > 1 )
{
ptr = ptr -> next;
rec_number --;
}
if ( !ptr )
{
return SQL_NO_DATA;
}
}
else if ( !__is_env( head ) && __get_connection( head ) -> state != STATE_C2 )
{
rec_number -= head -> sql_diag_head.internal_count;
if ( __get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELDW( __get_connection( head )))
{
SQLRETURN ret;
SQLWCHAR *s1 = NULL;
int char_buffer_len = sizeof( SQLWCHAR ) * buffer_length;
if ( buffer_length > 0 )
{
s1 = malloc( char_buffer_len + sizeof( SQLWCHAR ));
}
ret = SQLGETDIAGFIELDW( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
diag_identifier,
s1 ? s1 : diag_info_ptr,
char_buffer_len,
string_length_ptr );
if ( SQL_SUCCEEDED( ret ) && s1 && diag_info_ptr )
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, s1, SQL_NTS, __get_connection( head ));
}
if ( s1 )
{
free( s1 );
}
if ( string_length_ptr && *string_length_ptr > 0 )
{
*string_length_ptr /= sizeof( SQLWCHAR );
}
if ( SQL_SUCCEEDED( ret ) && diag_identifier == SQL_DIAG_SQLSTATE )
{
/*
* map 3 to 2 if required
*/
if ( diag_info_ptr )
{
if ( diag_info_ptr )
__map_error_state( diag_info_ptr, __get_version( head ));
}
}
return ret;
}
else if ( !__get_connection( head ) -> unicode_driver &&
CHECK_SQLGETDIAGFIELD( __get_connection( head )))
{
SQLRETURN ret;
ret = SQLGETDIAGFIELD( __get_connection( head ),
head -> handle_type,
__get_driver_handle( head ),
rec_number,
diag_identifier,
diag_info_ptr,
buffer_length,
string_length_ptr );
if ( SQL_SUCCEEDED( ret ) && diag_identifier == SQL_DIAG_SQLSTATE )
{
/*
* map 3 to 2 if required
*/
if ( diag_info_ptr )
{
if ( diag_info_ptr )
__map_error_state( diag_info_ptr, __get_version( head ));
}
}
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;
}
}
}
else
{
return SQL_NO_DATA;
}
/*
* if we are here ptr should point to the local error
* record
*/
switch( diag_identifier )
{
case SQL_DIAG_CLASS_ORIGIN:
{
if ( SQL_SUCCEEDED( ptr -> diag_class_origin_ret ))
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, ptr -> diag_class_origin, buffer_length, __get_connection( head ));
if ( string_length_ptr )
{
*string_length_ptr = wide_strlen( ptr -> diag_class_origin );
}
return ptr -> diag_class_origin_ret;
}
else
{
return ptr -> diag_class_origin_ret;
}
}
break;
case SQL_DIAG_COLUMN_NUMBER:
{
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &ptr -> diag_column_number, sizeof( SQLINTEGER ));
}
return SQL_SUCCESS;
}
break;
case SQL_DIAG_CONNECTION_NAME:
{
if ( SQL_SUCCEEDED( ptr -> diag_connection_name_ret ))
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, ptr -> diag_connection_name, buffer_length, __get_connection( head ));
if ( string_length_ptr )
{
*string_length_ptr = wide_strlen( ptr -> diag_connection_name );
}
return ptr -> diag_connection_name_ret;
}
else
{
return ptr -> diag_connection_name_ret;
}
}
break;
case SQL_DIAG_MESSAGE_TEXT:
{
char *str;
int ret = SQL_SUCCESS;
str = unicode_to_ansi_alloc( ptr -> msg, SQL_NTS, __get_connection( head ));
if ( diag_info_ptr )
{
if ( buffer_length >= strlen( str ) + 1 )
{
strcpy( diag_info_ptr, str );
}
else
{
ret = SQL_SUCCESS_WITH_INFO;
memcpy( diag_info_ptr, str, buffer_length - 1 );
(( char * ) diag_info_ptr )[ buffer_length - 1 ] = '\0';
}
}
if ( string_length_ptr )
{
*string_length_ptr = strlen( str );
}
if ( str )
{
free( str );
}
return ret;
}
break;
case SQL_DIAG_NATIVE:
{
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &ptr -> native_error, sizeof( SQLINTEGER ));
}
return SQL_SUCCESS;
}
break;
case SQL_DIAG_ROW_NUMBER:
{
if ( diag_info_ptr )
{
memcpy( diag_info_ptr, &ptr -> diag_row_number, sizeof( SQLLEN ));
}
return SQL_SUCCESS;
}
break;
case SQL_DIAG_SERVER_NAME:
{
if ( SQL_SUCCEEDED( ptr -> diag_server_name_ret ))
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, ptr -> diag_server_name, buffer_length, __get_connection( head ));
if ( string_length_ptr )
{
*string_length_ptr = wide_strlen( ptr -> diag_server_name );
}
return ptr -> diag_server_name_ret;
}
else
{
return ptr -> diag_server_name_ret;
}
}
break;
case SQL_DIAG_SQLSTATE:
{
char *str;
int ret = SQL_SUCCESS;
str = unicode_to_ansi_alloc( ptr -> sqlstate, SQL_NTS, __get_connection( head ));
if ( diag_info_ptr )
{
if ( buffer_length >= strlen( str ) + 1 )
{
strcpy( diag_info_ptr, str );
}
else
{
ret = SQL_SUCCESS_WITH_INFO;
memcpy( diag_info_ptr, str, buffer_length - 1 );
(( char * ) diag_info_ptr )[ buffer_length - 1 ] = '\0';
}
/*
* map 3 to 2 if required
*/
if ( diag_info_ptr )
__map_error_state( diag_info_ptr, __get_version( head ));
}
if ( string_length_ptr )
{
*string_length_ptr = strlen( str );
}
if ( str )
{
free( str );
}
return ret;
}
break;
case SQL_DIAG_SUBCLASS_ORIGIN:
{
if ( SQL_SUCCEEDED( ptr -> diag_subclass_origin_ret ))
{
unicode_to_ansi_copy( diag_info_ptr, buffer_length, ptr -> diag_subclass_origin, buffer_length, __get_connection( head ));
if ( string_length_ptr )
{
*string_length_ptr = wide_strlen( ptr -> diag_subclass_origin );
}
return ptr -> diag_subclass_origin_ret;
}
else
{
return ptr -> diag_subclass_origin_ret;
}
}
break;
}
return SQL_SUCCESS;
}
SQLRETURN SQLExecDirectW( SQLHSTMT statement_handle,
SQLWCHAR *statement_text,
SQLINTEGER text_length )
{
DMHSTMT statement = (DMHSTMT) statement_handle;
SQLRETURN ret;
SQLCHAR *s1;
SQLCHAR s2[ 100 + LOG_MESSAGE_LEN ];
/*
* check statement
*/
if ( !__validate_stmt( statement ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHSTMT parent_statement;
parent_statement = find_parent_handle( statement, SQL_HANDLE_STMT );
if ( parent_statement ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLEXECDIRECTW( parent_statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLEXECDIRECTW( parent_statement -> connection,
statement,
statement_text,
text_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( statement );
if ( log_info.log_flag )
{
/*
* allocate some space for the buffer
*/
if ( statement_text && text_length == SQL_NTS )
{
s1 = malloc( wide_strlen( statement_text ) * 2 + LOG_MESSAGE_LEN * 2 );
}
else if ( statement_text )
{
s1 = malloc( text_length + LOG_MESSAGE_LEN * 2 );
}
else
{
s1 = malloc( LOG_MESSAGE_LEN * 2 );
}
sprintf( statement -> msg, "\n\t\tEntry:\
\n\t\t\tStatement = %p\
\n\t\t\tSQL = %s",
statement,
__wstring_with_length( s1, statement_text, text_length ));
free( s1 );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
thread_protect( SQL_HANDLE_STMT, statement );
if ( !statement_text )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &statement -> error,
ERROR_HY009, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( text_length <= 0 && text_length != SQL_NTS )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY090" );
__post_internal_error( &statement -> error,
ERROR_HY090, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
/*
* check states
*/
#ifdef NR_PROBE
if ( statement -> state == STATE_S5 ||
statement -> state == STATE_S6 ||
statement -> state == STATE_S7 )
#else
if (( statement -> state == STATE_S6 && statement -> eod == 0 ) ||
statement -> state == STATE_S7 )
#endif
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: 24000" );
__post_internal_error( &statement -> error,
ERROR_24000, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &statement -> error,
ERROR_HY010, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
if ( statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
if ( statement -> interupted_func != SQL_API_SQLEXECDIRECT )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &statement -> error,
ERROR_HY010, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
}
if ( statement -> connection -> unicode_driver ||
CHECK_SQLEXECDIRECTW( statement -> connection ))
{
#ifdef NR_PROBE
if ( !CHECK_SQLEXECDIRECTW( statement -> connection ) ||
!CHECK_SQLNUMRESULTCOLS( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
#else
if ( !CHECK_SQLEXECDIRECTW( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
#endif
ret = SQLEXECDIRECTW( statement -> connection,
statement -> driver_stmt,
statement_text,
text_length );
}
else
{
SQLCHAR *as1 = NULL;
int clen;
#ifdef NR_PROBE
if ( !CHECK_SQLEXECDIRECT( statement -> connection ) ||
!CHECK_SQLNUMRESULTCOLS( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
#else
if ( !CHECK_SQLEXECDIRECT( statement -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &statement -> error,
ERROR_IM001, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
#endif
as1 = (SQLCHAR*) unicode_to_ansi_alloc( statement_text, text_length, statement -> connection, &clen );
text_length = clen;
ret = SQLEXECDIRECT( statement -> connection,
statement -> driver_stmt,
as1,
text_length );
if ( as1 )
free( as1 );
}
if ( SQL_SUCCEEDED( ret ))
{
#ifdef NR_PROBE
SQLRETURN local_ret;
/*
* grab any errors
*/
if ( ret == SQL_SUCCESS_WITH_INFO )
{
function_return_ex( IGNORE_THREAD, statement, ret, TRUE );
}
local_ret = SQLNUMRESULTCOLS( statement -> connection,
statement -> driver_stmt, &statement -> numcols );
if ( statement -> numcols > 0 )
{
statement -> state = STATE_S5;
}
else
{
statement -> state = STATE_S4;
}
#else
/*
* We don't know for sure
*/
statement -> hascols = 1;
statement -> state = STATE_S5;
#endif
statement -> prepared = 0;
/*
* there is a issue here with transactions, but for the
* moment
*
statement -> connection -> state = STATE_C6;
*/
}
else if ( ret == SQL_NEED_DATA )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
statement -> interupted_state = statement -> state;
statement -> state = STATE_S8;
statement -> prepared = 0;
}
else if ( ret == SQL_PARAM_DATA_AVAILABLE )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
statement -> interupted_state = statement -> state;
statement -> state = STATE_S13;
}
else if ( ret == SQL_STILL_EXECUTING )
{
statement -> interupted_func = SQL_API_SQLEXECDIRECT;
if ( statement -> state != STATE_S11 &&
statement -> state != STATE_S12 )
statement -> state = STATE_S11;
statement -> prepared = 0;
}
else
{
statement -> state = STATE_S1;
}
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tExit:[%s]",
__get_return_status( ret, s2 ));
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
return function_return( SQL_HANDLE_STMT, statement, ret );
}
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 SQLSetConnectOptionW( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLULEN value )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR buffer[ 512 ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
{
if ((SQLLEN) value != SQL_OPT_TRACE_OFF &&
(SQLLEN) value != SQL_OPT_TRACE_ON )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
if ( value == SQL_OPT_TRACE_OFF )
{
log_info.log_flag = 0;
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( option == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if (((SQLWCHAR*)value)[ 0 ] == 0 )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
else
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = unicode_to_ansi_alloc((SQLWCHAR *) value, SQL_NTS, connection );
}
}
else
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
return SQL_SUCCESS;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSETCONNECTOPTIONW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSETCONNECTOPTIONW( parent_connection,
connection_handle,
option,
value );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tOption = %s\
\n\t\t\tValue = %d",
connection,
__con_attr_as_string( s1, option ),
(int)value );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
SQLRETURN SQLSetConnectAttrW( SQLHDBC connection_handle,
SQLINTEGER attribute,
SQLPOINTER value,
SQLINTEGER string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
SQLWCHAR buffer[ 512 ];
/*
* doesn't require a handle
*/
if ( attribute == SQL_ATTR_TRACE )
{
if ((SQLLEN) value != SQL_OPT_TRACE_OFF &&
(SQLLEN) value != SQL_OPT_TRACE_ON )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
if ((SQLLEN) value == SQL_OPT_TRACE_OFF )
{
char force_string[ 30 ];
SQLGetPrivateProfileString( "ODBC", "ForceTrace", "0",
force_string, sizeof( force_string ),
"ODBCINST.INI" );
if ( force_string[ 0 ] == '1' ||
toupper( force_string[ 0 ] ) == 'Y' ||
( toupper( force_string[ 0 ] ) == 'O' &&
toupper( force_string[ 1 ] ) == 'N' ))
{
if ( log_info.log_flag )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Application tried to turn logging off" );
}
}
else
{
if ( log_info.log_flag )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Application turning logging off" );
}
log_info.log_flag = 0;
}
}
else
{
log_info.log_flag = 1;
}
return SQL_SUCCESS;
}
else if ( attribute == SQL_ATTR_TRACEFILE )
{
if ( value )
{
if (((SQLWCHAR*)value)[ 0 ] == 0 )
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
else
{
if ( log_info.log_file_name )
{
free( log_info.log_file_name );
}
log_info.log_file_name = unicode_to_ansi_alloc((SQLWCHAR *) value, SQL_NTS, connection );
}
}
else
{
if ( __validate_dbc( connection ))
{
thread_protect( SQL_HANDLE_DBC, connection );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY009" );
__post_internal_error( &connection -> error,
ERROR_HY009, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DBC, connection, SQL_ERROR );
}
else
{
return SQL_INVALID_HANDLE;
}
}
return SQL_SUCCESS;
}
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDBC parent_connection;
parent_connection = find_parent_handle( connection, SQL_HANDLE_DBC );
if ( parent_connection ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLSETCONNECTATTRW( parent_connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLSETCONNECTATTRW( parent_connection,
connection_handle,
attribute,
value,
string_length );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( connection );
if ( log_info.log_flag )
{
sprintf( connection -> msg, "\n\t\tEntry:\
\n\t\t\tConnection = %p\
\n\t\t\tAttribute = %s\
\n\t\t\tValue = %p\
\n\t\t\tStrLen = %d",
connection,
__con_attr_as_string( s1, attribute ),
value,
(int)string_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
