SQLRETURN SQLSetDescField( SQLHDESC descriptor_handle,
SQLSMALLINT rec_number,
SQLSMALLINT field_identifier,
SQLPOINTER value,
SQLINTEGER buffer_length )
{
/*
* not quite sure how the descriptor can be
* allocated to a statement, all the documentation talks
* about state transitions on statement states, but the
* descriptor may be allocated with more than one statement
* at one time. Which one should I check ?
*/
DMHDESC descriptor = (DMHDESC) descriptor_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
if ( log_info.log_flag )
{
sprintf( descriptor -> msg, "\n\t\tEntry:\
\n\t\t\tDescriptor = %p\
\n\t\t\tRec Number = %d\
\n\t\t\tField Ident = %s\
\n\t\t\tValue = %p\
\n\t\t\tBuffer Length = %d",
descriptor,
rec_number,
__desc_attr_as_string( s1, field_identifier ),
value,
(int)buffer_length );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
descriptor -> msg );
}
SQLRETURN SQLEndTran( SQLSMALLINT handle_type,
SQLHANDLE handle,
SQLSMALLINT completion_type )
{
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
if ( handle_type != SQL_HANDLE_ENV && handle_type != SQL_HANDLE_DBC )
{
DMHSTMT statement;
DMHDESC descriptor;
if ( handle_type == SQL_HANDLE_STMT ) {
if ( !__validate_stmt(( DMHSTMT ) handle ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
statement = (DMHSTMT) handle;
function_entry( statement );
thread_protect( SQL_HANDLE_STMT, statement );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY092" );
__post_internal_error( &statement -> error,
ERROR_HY092, NULL,
statement -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_STMT, statement, SQL_ERROR );
}
else if ( handle_type == SQL_HANDLE_DESC ) {
if ( !__validate_desc(( DMHDESC ) handle ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
descriptor = (DMHDESC) handle;
function_entry( descriptor );
thread_protect( SQL_HANDLE_DESC, descriptor );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY092" );
__post_internal_error( &descriptor -> error,
ERROR_HY092, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
else {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
}
if ( handle_type == SQL_HANDLE_ENV )
{
DMHENV environment = (DMHENV) handle;
DMHDBC connection;
SQLRETURN ret;
if ( !__validate_env( environment ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( environment );
if ( log_info.log_flag )
{
sprintf( environment -> msg, "\n\t\tEntry:\
\n\t\t\tEnvironment = %p\
\n\t\t\tCompletion Type = %d",
(void*)environment,
(int)completion_type );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
SQLRETURN SQLGetDescRecW( SQLHDESC descriptor_handle,
SQLSMALLINT rec_number,
SQLWCHAR *name,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length,
SQLSMALLINT *type,
SQLSMALLINT *sub_type,
SQLLEN *length,
SQLSMALLINT *precision,
SQLSMALLINT *scale,
SQLSMALLINT *nullable )
{
/*
* not quite sure how the descriptor can be
* allocated to a statement, all the documentation talks
* about state transitions on statement states, but the
* descriptor may be allocated with more than one statement
* at one time. Which one should I check ?
*/
DMHDESC descriptor = (DMHDESC) descriptor_handle;
SQLRETURN ret;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ], s2[ 100 + LOG_MESSAGE_LEN ], s3[ 100 + LOG_MESSAGE_LEN ], s4[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s5[ 100 + LOG_MESSAGE_LEN ], s6[ 100 + LOG_MESSAGE_LEN ], s7[ 100 + LOG_MESSAGE_LEN ];
SQLCHAR s8[ 100 + LOG_MESSAGE_LEN ];
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
#ifdef WITH_HANDLE_REDIRECT
{
DMHDESC parent_desc;
parent_desc = find_parent_handle( descriptor, SQL_HANDLE_DESC );
if ( parent_desc ) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: found parent handle" );
if ( CHECK_SQLGETDESCRECW( parent_desc -> connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Info: calling redirected driver function" );
return SQLGETDESCRECW( parent_desc -> connection,
descriptor,
rec_number,
name,
buffer_length,
string_length,
type,
sub_type,
length,
precision,
scale,
nullable );
}
}
}
#endif
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
if ( log_info.log_flag )
{
sprintf( descriptor -> msg, "\n\t\tEntry:\
\n\t\t\tDescriptor = %p\
\n\t\t\tRec Number = %d\
\n\t\t\tName = %p\
\n\t\t\tBuffer length = %d\
\n\t\t\tString Length = %p\
\n\t\t\tType = %p\
\n\t\t\tSub Type = %p\
\n\t\t\tLength = %p\
\n\t\t\tPrecision = %p\
\n\t\t\tScale = %p\
\n\t\t\tNullable = %p",
descriptor,
rec_number,
name,
buffer_length,
string_length,
type,
sub_type,
length,
precision,
scale,
nullable );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
descriptor -> msg );
}
SQLRETURN __SQLFreeHandle( SQLSMALLINT handle_type,
SQLHANDLE handle )
{
switch( handle_type )
{
case SQL_HANDLE_ENV:
{
DMHENV environment = (DMHENV)handle;
/*
* check environment
*/
if ( !__validate_env( environment ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( environment );
if ( log_info.log_flag )
{
sprintf( environment -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
thread_protect( SQL_HANDLE_ENV, environment );
/*
* check states
*/
if ( environment -> state != STATE_E1 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &environment -> error,
ERROR_HY010, NULL,
environment -> requested_version );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
thread_release( SQL_HANDLE_ENV, environment );
__release_env( environment );
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_DBC:
{
DMHDBC connection = (DMHDBC)handle;
DMHENV environment;
/*
* check connection
*/
if ( !__validate_dbc( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( connection );
environment = connection -> environment;
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
thread_protect( SQL_HANDLE_ENV, environment );
/*
* check states
*/
if ( connection -> state != STATE_C2 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &connection -> error,
ERROR_HY010, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_ENV, environment, SQL_ERROR );
}
environment -> connection_count --;
if ( environment -> connection_count == 0 )
{
environment -> state = STATE_E1;
}
environment = connection -> environment;
__release_attr_str( &connection -> env_attribute );
__release_attr_str( &connection -> dbc_attribute );
__release_attr_str( &connection -> stmt_attribute );
__disconnect_part_one( connection );
__release_dbc( connection );
if ( log_info.log_flag )
{
sprintf( environment -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
environment -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(environment->sh, UODBC_STATS_TYPE_HDBC,
(void *)-1);
#endif
thread_release( SQL_HANDLE_ENV, environment );
return SQL_SUCCESS;
}
break;
case SQL_HANDLE_STMT:
{
DMHSTMT statement = (DMHSTMT)handle;
DMHDBC connection;
SQLRETURN ret;
/*
* 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 );
connection = statement -> connection;
if ( log_info.log_flag )
{
sprintf( statement -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
statement -> msg );
}
thread_protect( SQL_HANDLE_STMT, statement );
/*
* check states
*/
if ( statement -> state == STATE_S8 ||
statement -> state == STATE_S9 ||
statement -> state == STATE_S10 ||
statement -> state == STATE_S11 ||
statement -> state == STATE_S12 )
{
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 ( !CHECK_SQLFREEHANDLE( statement -> connection ))
{
if ( !CHECK_SQLFREESTMT( 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
{
ret = SQLFREESTMT( statement -> connection,
statement -> driver_stmt,
SQL_DROP );
}
}
else
{
ret = SQLFREEHANDLE( statement -> connection,
handle_type,
statement -> driver_stmt );
}
if ( SQL_SUCCEEDED( ret ))
{
/*
* break any association
*/
if ( statement -> ard ) {
statement -> ard -> associated_with = NULL;
}
if ( statement -> apd ) {
statement -> apd -> associated_with = NULL;
}
/*
* release the implicit descriptors,
* this matches the tests in SQLAllocHandle
*/
if (( statement -> connection -> driver_act_ver == 3 &&
CHECK_SQLGETSTMTATTR( connection )) ||
CHECK_SQLGETSTMTATTRW( connection ))
{
if ( statement -> implicit_ard )
__release_desc( statement -> implicit_ard );
if ( statement -> implicit_apd )
__release_desc( statement -> implicit_apd );
if ( statement -> implicit_ird )
__release_desc( statement -> implicit_ird );
if ( statement -> implicit_ipd )
__release_desc( statement -> implicit_ipd );
}
statement -> connection -> statement_count --;
thread_release( SQL_HANDLE_STMT, statement );
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh,
UODBC_STATS_TYPE_HSTMT, (void *)-1);
#endif
__release_stmt( statement );
}
else
{
thread_release( SQL_HANDLE_STMT, statement );
}
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
return function_return( IGNORE_THREAD, connection, ret );
}
break;
case SQL_HANDLE_DESC:
{
DMHDESC descriptor = (DMHDESC)handle;
DMHDBC connection;
SQLRETURN ret;
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
connection = descriptor -> connection;
if ( log_info.log_flag )
{
sprintf( descriptor -> msg,
"\n\t\tEntry:\n\t\t\tHandle Type = %d\n\t\t\tInput Handle = %p",
handle_type,
(void*)handle );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
descriptor -> msg );
}
if ( descriptor -> implicit )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY017" );
__post_internal_error( &descriptor -> error,
ERROR_HY017, NULL,
connection -> environment -> requested_version );
return function_return( IGNORE_THREAD, descriptor, SQL_ERROR );
}
thread_protect( SQL_HANDLE_DESC, descriptor );
if ( !CHECK_SQLFREEHANDLE( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &descriptor -> error,
ERROR_IM001, NULL,
connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
else
{
ret = SQLFREEHANDLE( connection,
handle_type,
descriptor -> driver_desc );
}
/*
* check status of statements associated with this descriptor
*/
if( __check_stmt_from_desc( descriptor, STATE_S8 ) ||
__check_stmt_from_desc( descriptor, STATE_S9 ) ||
__check_stmt_from_desc( descriptor, STATE_S10 ) ||
__check_stmt_from_desc( descriptor, STATE_S11 ) ||
__check_stmt_from_desc( descriptor, STATE_S12 )) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &descriptor -> error,
ERROR_HY010, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
thread_release( SQL_HANDLE_DESC, descriptor );
__release_desc( descriptor );
if ( log_info.log_flag )
{
sprintf( connection -> msg,
"\n\t\tExit:[SQL_SUCCESS]" );
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
connection -> msg );
}
#if defined ( COLLECT_STATS ) && defined( HAVE_SYS_SEM_H )
uodbc_update_stats(connection->environment->sh,
UODBC_STATS_TYPE_HDESC, (void *)-1);
#endif
return function_return( IGNORE_THREAD, connection, SQL_SUCCESS );
}
break;
default:
/*
* there is nothing to report a error on
*/
return SQL_ERROR;
}
}
SQLRETURN SQLSetDescRec( SQLHDESC descriptor_handle,
SQLSMALLINT rec_number,
SQLSMALLINT type,
SQLSMALLINT subtype,
SQLLEN length,
SQLSMALLINT precision,
SQLSMALLINT scale,
SQLPOINTER data,
SQLLEN *string_length,
SQLLEN *indicator )
{
/*
* not quite sure how the descriptor can be
* allocated to a statement, all the documentation talks
* about state transitions on statement states, but the
* descriptor may be allocated with more than one statement
* at one time. Which one should I check ?
*/
DMHDESC descriptor = (DMHDESC) descriptor_handle;
SQLRETURN ret;
/*
* check descriptor
*/
if ( !__validate_desc( descriptor ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: SQL_INVALID_HANDLE" );
return SQL_INVALID_HANDLE;
}
function_entry( descriptor );
thread_protect( SQL_HANDLE_DESC, descriptor );
if ( descriptor -> connection -> state < STATE_C4 )
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &descriptor -> error,
ERROR_HY010, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
/*
* check status of statements associated with this descriptor
*/
if( __check_stmt_from_desc( descriptor, STATE_S8 ) ||
__check_stmt_from_desc( descriptor, STATE_S9 ) ||
__check_stmt_from_desc( descriptor, STATE_S10 ) ||
__check_stmt_from_desc( descriptor, STATE_S11 ) ||
__check_stmt_from_desc( descriptor, STATE_S12 )) {
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY010" );
__post_internal_error( &descriptor -> error,
ERROR_HY010, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
if ( !CHECK_SQLSETDESCREC( descriptor -> connection ))
{
__post_internal_error( &descriptor -> error,
ERROR_IM001, NULL,
descriptor -> connection -> environment -> requested_version );
return function_return( SQL_HANDLE_DESC, descriptor, SQL_ERROR );
}
ret = SQLSETDESCREC( descriptor -> connection,
descriptor -> driver_desc,
rec_number,
type,
subtype,
length,
precision,
scale,
data,
string_length,
indicator );
return function_return( SQL_HANDLE_DESC, descriptor, ret );
}
SQLRETURN __SQLGetInfo( SQLHDBC connection_handle,
SQLUSMALLINT info_type,
SQLPOINTER info_value,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length )
{
DMHDBC connection = (DMHDBC)connection_handle;
SQLRETURN ret = SQL_SUCCESS;
int type;
SQLUSMALLINT sval;
char txt[ 30 ], *cptr;
SQLPOINTER *ptr;
switch ( info_type )
{
case SQL_DATA_SOURCE_NAME:
type = 1;
cptr = connection -> dsn;
break;
case SQL_DM_VER:
type = 1;
sprintf( txt, "%02d.%02d.%04d.%04d",
SQL_SPEC_MAJOR, SQL_SPEC_MINOR,
atoi( VERSION ), atoi( VERSION + 2 ));
cptr = txt;
break;
case SQL_ODBC_VER:
type = 1;
sprintf( txt, "%02d.%02d",
SQL_SPEC_MAJOR, SQL_SPEC_MINOR );
cptr = txt;
break;
case SQL_DRIVER_HDBC:
type = 2;
ptr = (SQLPOINTER) connection -> driver_dbc;
break;
case SQL_DRIVER_HENV:
type = 2;
ptr = (SQLPOINTER) connection -> driver_env;
break;
case SQL_DRIVER_HDESC:
{
if ( info_value )
{
DMHDESC hdesc = *((DMHDESC*) info_value);
type = 2;
if ( __validate_desc( hdesc ))
{
ptr = (SQLPOINTER) hdesc -> driver_desc;
}
else
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return SQL_ERROR;
}
}
}
break;
case SQL_DRIVER_HLIB:
type = 2;
ptr = connection -> dl_handle;
break;
case SQL_DRIVER_HSTMT:
{
if ( info_value )
{
DMHSTMT hstmt = *((DMHSTMT*) info_value);
type = 2;
if ( __validate_stmt( hstmt ))
{
ptr = (SQLPOINTER) hstmt -> driver_stmt;
}
else
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: HY024" );
__post_internal_error( &connection -> error,
ERROR_HY024, NULL,
connection -> environment -> requested_version );
return SQL_ERROR;
}
}
}
break;
case SQL_XOPEN_CLI_YEAR:
type = 1;
cptr = connection -> cli_year;
break;
case SQL_ATTR_DRIVER_THREADING:
type = 3;
sval = connection -> threading_level;
break;
default:
/*
* pass all the others on
*/
if ( connection -> unicode_driver )
{
SQLWCHAR *s1 = NULL;
if ( !CHECK_SQLGETINFOW( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &connection -> error,
ERROR_IM001, NULL,
connection -> environment -> requested_version );
return SQL_ERROR;
}
switch( info_type )
{
case SQL_ACCESSIBLE_PROCEDURES:
case SQL_ACCESSIBLE_TABLES:
case SQL_CATALOG_NAME:
case SQL_CATALOG_NAME_SEPARATOR:
case SQL_CATALOG_TERM:
case SQL_COLLATION_SEQ:
case SQL_COLUMN_ALIAS:
case SQL_DATA_SOURCE_NAME:
case SQL_DATA_SOURCE_READ_ONLY:
case SQL_DATABASE_NAME:
case SQL_DBMS_NAME:
case SQL_DBMS_VER:
case SQL_DESCRIBE_PARAMETER:
case SQL_DRIVER_NAME:
case SQL_DRIVER_ODBC_VER:
case SQL_DRIVER_VER:
case SQL_ODBC_VER:
case SQL_EXPRESSIONS_IN_ORDERBY:
case SQL_IDENTIFIER_QUOTE_CHAR:
case SQL_INTEGRITY:
case SQL_KEYWORDS:
case SQL_LIKE_ESCAPE_CLAUSE:
case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
case SQL_MULT_RESULT_SETS:
case SQL_MULTIPLE_ACTIVE_TXN:
case SQL_NEED_LONG_DATA_LEN:
case SQL_ORDER_BY_COLUMNS_IN_SELECT:
case SQL_PROCEDURE_TERM:
case SQL_PROCEDURES:
case SQL_ROW_UPDATES:
case SQL_SCHEMA_TERM:
case SQL_SEARCH_PATTERN_ESCAPE:
case SQL_SERVER_NAME:
case SQL_SPECIAL_CHARACTERS:
case SQL_TABLE_TERM:
case SQL_USER_NAME:
case SQL_XOPEN_CLI_YEAR:
case SQL_OUTER_JOINS:
if ( info_value && buffer_length > 0 )
{
buffer_length = sizeof( SQLWCHAR ) * ( buffer_length + 1 );
s1 = malloc( buffer_length );
}
break;
}
ret = SQLGETINFOW( connection,
connection -> driver_dbc,
info_type,
s1 ? s1 : info_value,
buffer_length,
string_length );
switch( info_type )
{
case SQL_ACCESSIBLE_PROCEDURES:
case SQL_ACCESSIBLE_TABLES:
case SQL_CATALOG_NAME:
case SQL_CATALOG_NAME_SEPARATOR:
case SQL_CATALOG_TERM:
case SQL_COLLATION_SEQ:
case SQL_COLUMN_ALIAS:
case SQL_DATA_SOURCE_NAME:
case SQL_DATA_SOURCE_READ_ONLY:
case SQL_DATABASE_NAME:
case SQL_DBMS_NAME:
case SQL_DBMS_VER:
case SQL_DESCRIBE_PARAMETER:
case SQL_DRIVER_NAME:
case SQL_DRIVER_ODBC_VER:
case SQL_DRIVER_VER:
case SQL_ODBC_VER:
case SQL_EXPRESSIONS_IN_ORDERBY:
case SQL_IDENTIFIER_QUOTE_CHAR:
case SQL_INTEGRITY:
case SQL_KEYWORDS:
case SQL_LIKE_ESCAPE_CLAUSE:
case SQL_MAX_ROW_SIZE_INCLUDES_LONG:
case SQL_MULT_RESULT_SETS:
case SQL_MULTIPLE_ACTIVE_TXN:
case SQL_NEED_LONG_DATA_LEN:
case SQL_ORDER_BY_COLUMNS_IN_SELECT:
case SQL_PROCEDURE_TERM:
case SQL_PROCEDURES:
case SQL_ROW_UPDATES:
case SQL_SCHEMA_TERM:
case SQL_SEARCH_PATTERN_ESCAPE:
case SQL_SERVER_NAME:
case SQL_SPECIAL_CHARACTERS:
case SQL_TABLE_TERM:
case SQL_USER_NAME:
case SQL_XOPEN_CLI_YEAR:
case SQL_OUTER_JOINS:
if ( SQL_SUCCEEDED( ret ) && info_value && s1 )
{
unicode_to_ansi_copy( info_value, buffer_length, s1, SQL_NTS, connection, NULL );
}
if ( SQL_SUCCEEDED( ret ) && string_length && info_value )
{
*string_length = strlen(info_value);
}
break;
}
if ( s1 )
{
free( s1 );
}
}
else
{
if ( !CHECK_SQLGETINFO( connection ))
{
dm_log_write( __FILE__,
__LINE__,
LOG_INFO,
LOG_INFO,
"Error: IM001" );
__post_internal_error( &connection -> error,
ERROR_IM001, NULL,
connection -> environment -> requested_version );
return SQL_ERROR;
}
ret = SQLGETINFO( connection,
connection -> driver_dbc,
info_type,
info_value,
buffer_length,
string_length );
}
return ret;
}
if ( type == 1 )
{
if ( string_length )
*string_length = strlen( cptr );
if ( info_value )
{
if ( buffer_length > strlen( cptr ) + 1 )
{
strcpy( info_value, cptr );
}
else
{
memcpy( info_value, cptr, buffer_length - 1 );
((char*)info_value)[ buffer_length - 1 ] = '\0';
ret = SQL_SUCCESS_WITH_INFO;
}
}
}
else if ( type == 2 )
{
if ( info_value )
*((void **)info_value) = ptr;
if ( string_length )
*string_length = sizeof( SQLPOINTER );
}
else if ( type == 3 )
{
if ( info_value )
*((SQLUSMALLINT *)info_value) = sval;
if ( string_length )
*string_length = sizeof( SQLUSMALLINT );
}
return ret;
}
