scsh-conservatory
/
scsh-0.6
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
scsh-0.6/scsh/odbc/odbc.c

2425 lines
72 KiB
C
Raw Blame History

#include "odbc.h"
/*
*
* PART 1
*
* Connecting to a data source
*
*/
/* Call SQLAllocHandle and get an environment handle. After that
* call odbc_set_environment to set the ODBC version */
s48_value odbc_alloc_environment_handle()
{
SQLHENV henv;
SQLRETURN retval;
#if (ODBCVER >= 0x300)
retval = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
ODBC_DEBUG_PRINTF_2("SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, ...): %x\n", henv);
#else
retval = SQLAllocEnv(&henv);
ODBC_DEBUG_PRINTF_2("SQLAllocEnv(...): %x\n", henv);
#endif /* (ODBCVER >= 0x300) */
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer((long)henv) :
S48_UNSPECIFIC);
}
/* Given a valid environment handle get a connection handle */
s48_value odbc_alloc_connection_handle(s48_value env_handle)
{
SQLHDBC hdbc;
SQLRETURN retval;
SQLHENV envh;
envh = (SQLHENV) s48_extract_integer(env_handle);
#if (ODBCVER >= 0x300)
retval = SQLAllocHandle(SQL_HANDLE_DBC, envh, &hdbc);
ODBC_DEBUG_PRINTF_3("SQLAllocHandle(SQL_HANDLE_DBC, %x, ...): %x\n", envh, hdbc);
#else
retval = SQLAllocConnect(envh, &hdbc);
ODBC_DEBUG_PRINTF_3("SQLAllocConnect(%x, ...): %x\n", envh, hdbc);
#endif /* ODBCVER >= 0x300 */
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer((long)hdbc) :
S48_UNSPECIFIC);
}
/* Given a valid connection handle get a statement handle */
s48_value odbc_alloc_statement_handle(s48_value conn_handle)
{
SQLHSTMT hstmt;
SQLRETURN retval;
SQLHANDLE ch;
ch = (SQLHANDLE) s48_extract_integer(conn_handle);
#if (ODBCVER >= 0x300)
retval = SQLAllocHandle(SQL_HANDLE_STMT, ch, &hstmt);
ODBC_DEBUG_PRINTF_3("SQLAllocHandle() %x %x\n", ch, hstmt);
#else
retval = SQLAllocStmt(ch, &hstmt);
ODBC_DEBUG_PRINTF_3("SQLAllocStmt() %x %x\n", ch, hstmt);
#endif /* ODBCVER >= 0x300 */
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer((long)hstmt) :
S48_UNSPECIFIC);
}
/* Connect to a server */
s48_value odbc_sql_connect(s48_value connection_handle,
s48_value ds_name,
s48_value user_name,
s48_value authentication)
{
SQLHDBC ch;
SQLCHAR *dsn, *user, *auth;
SQLRETURN retval;
dsn = (SQLCHAR *) s48_extract_string(ds_name);
user = (SQLCHAR *) s48_extract_string(user_name);
auth = (SQLCHAR *) s48_extract_string(authentication);
ch = (SQLHDBC) s48_extract_integer(connection_handle);
ODBC_DEBUG_PRINTF_5("odbc_sql_connect() %x '%s' '%s' '%s'\n",
ch, dsn, user,auth);
retval = SQLConnect(ch,
dsn, S48_STRING_LENGTH(ds_name),
user, S48_STRING_LENGTH(user_name),
auth, S48_STRING_LENGTH(authentication));
return s48_enter_integer(retval);
}
s48_value odbc_sql_browse_connect(s48_value conn_handle, s48_value conn_string)
{
SQLHDBC ch;
SQLCHAR *buffer = NULL;
SQLRETURN retval;
SQLSMALLINT buffer_needed, buffer_len;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
ch = (SQLHDBC) s48_extract_integer(conn_handle);
ODBC_DEBUG_PRINTF_3("odbc_sql_browse_connect() %x '%s'\n",
ch, s48_extract_string(conn_string));
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLBrowseConnect(ch, (SQLCHAR *) s48_extract_string(conn_string),
(SQLSMALLINT) S48_STRING_LENGTH(conn_string),
buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
res = s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_string(buffer) :
S48_UNSPECIFIC);
free(buffer);
S48_GC_UNPROTECT();
return res;
}
/*
*
* PART 2
*
* Obtaining information about a driver and data source
*
*/
/* Returns a list of available data sources. */
s48_value odbc_sql_data_sources(s48_value env_handle)
{
SQLHENV eh;
SQLUSMALLINT dir;
SQLRETURN retval;
int first;
SQLSMALLINT server_name_len, driver_descr_len;
SQLSMALLINT server_name_needed, driver_descr_needed;
SQLCHAR *server_name = NULL;
SQLCHAR *driver_descr = NULL;
s48_value res_list = S48_NULL;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res_list, res);
eh = (SQLHENV) s48_extract_integer(env_handle);
ODBC_DEBUG_PRINTF_1("odbc_sql_data_sources\n");
server_name_len = driver_descr_len = odbc_initial_retval_buffer_size;
first = 1;
for (;;)
{
for (;;)
{
odbc_sql_alloc((void **) &server_name, server_name_len, sizeof(SQLCHAR));
odbc_sql_alloc((void **) &driver_descr, driver_descr_len, sizeof(SQLCHAR));
retval = SQLDataSources(eh,
(first ? SQL_FETCH_FIRST : SQL_FETCH_NEXT),
server_name, sizeof(SQLCHAR)*server_name_len,
&server_name_needed,
driver_descr, sizeof(SQLCHAR)*driver_descr_len,
&driver_descr_needed);
if (SQL_SUCCEEDED(retval) && ((server_name_needed > server_name_len) ||
(driver_descr_needed > driver_descr_len)))
{
if (server_name_needed > server_name_len)
server_name_len = server_name_needed + 1;
if (driver_descr_needed > driver_descr_len)
driver_descr_len = driver_descr_needed + 1;
}
else
break;
}
if (SQL_SUCCEEDED(retval))
res_list = s48_cons(s48_cons(s48_enter_string(server_name),
s48_enter_string(driver_descr)),
res_list);
else
res_list = S48_UNSPECIFIC;
if (retval == SQL_NO_DATA)
{
res = s48_list_2(s48_enter_integer(retval), res_list);
free(server_name);
free(driver_descr);
S48_GC_UNPROTECT();
return res;
}
first = 0;
}
/* never reached */
S48_GC_UNPROTECT();
return s48_list_2(s48_enter_integer(retval), S48_UNSPECIFIC);
}
/* Returns the list of installed drivers and their attributes. */
s48_value odbc_sql_drivers(s48_value env_handle)
{
#if (ODBCVER >= 0x0200)
SQLHENV eh;
SQLRETURN retval;
int first;
SQLSMALLINT driver_descr_len, driver_attr_len;
SQLSMALLINT driver_descr_needed, driver_attr_needed;
SQLCHAR *driver_attr = NULL;
SQLCHAR *driver_descr = NULL;
s48_value res_list = S48_NULL;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, res_list);
eh = (SQLHENV) s48_extract_integer(env_handle);
ODBC_DEBUG_PRINTF_1("odbc_sql_drivers\n");
driver_descr_len = driver_attr_len = odbc_initial_retval_buffer_size;
first = 0;
for (;;)
{
for (;;)
{
odbc_sql_alloc((void **) &driver_descr, driver_descr_len, sizeof(SQLCHAR));
odbc_sql_alloc((void **) &driver_attr, driver_attr_len, sizeof(SQLCHAR));
retval = SQLDrivers(eh,
(SQLUSMALLINT) (first ? SQL_FETCH_FIRST : SQL_FETCH_NEXT),
driver_descr, driver_descr_len, &driver_descr_needed,
driver_attr, driver_attr_len, &driver_attr_needed);
if (SQL_SUCCEEDED(retval) && ((driver_descr_needed > driver_descr_len) ||
(driver_attr_needed > driver_attr_len)))
{
if (driver_descr_needed > driver_descr_len)
driver_descr_len = driver_descr_needed + 1;
if (driver_attr_needed > driver_attr_len)
driver_attr_len = driver_attr_needed + 1;
}
else
break;
}
if (SQL_SUCCEEDED(retval))
res_list = s48_cons(s48_cons(s48_enter_string(driver_descr),
s48_enter_string(driver_attr)),
res_list);
if (retval == SQL_NO_DATA)
{
res = s48_list_2(s48_enter_integer(retval), res_list);
free(driver_descr);
free(driver_attr);
S48_GC_UNPROTECT();
return res;
}
first = 1;
}
/* not reached */
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLDrivers", ODBCVER, 0x200);
#endif /* ODBCVER >= 0x200 */
}
/* Returns information about a specific driver and data source.
* (use if the information is an integer) */
s48_value odbc_sql_get_info_int(s48_value conn_handle, s48_value info_key)
{
SQLHDBC ch;
SQLUSMALLINT ik;
SQLRETURN retval;
SQLUINTEGER info;
SQLSMALLINT buffer_size;
ODBC_DEBUG_PRINTF_1("odbc_sql_get_info_int\n");
ch = (SQLHDBC) s48_extract_integer(conn_handle);
ik = (SQLUSMALLINT) s48_extract_integer(info_key);
retval = SQLGetInfo(ch, ik, &info, sizeof(SQLUINTEGER), &buffer_size);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(info) :
S48_UNSPECIFIC);
}
/* Returns information about a specific driver and data source.
* (use if the information is a string) */
s48_value odbc_sql_get_info_string(s48_value conn_handle, s48_value info_key)
{
SQLHDBC ch;
SQLUSMALLINT ik;
SQLRETURN retval;
SQLCHAR *buffer = NULL;
SQLSMALLINT buffer_needed, buffer_len;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_info_string\n");
ch = (SQLHDBC) s48_extract_integer(conn_handle);
ik = (SQLUSMALLINT) s48_extract_integer(info_key);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetInfo(ch, ik, buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
res = s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_string(buffer) :
S48_UNSPECIFIC);
free(buffer);
S48_GC_UNPROTECT();
return res;
}
/* Returns supported driver functions. (for a multiple functions) */
s48_value odbc_sql_get_func_exists(s48_value conn_handle, s48_value fun_id)
{
SQLHDBC ch;
SQLUSMALLINT fi, supported[SQL_API_ODBC3_ALL_FUNCTIONS_SIZE];
SQLRETURN retval;
int i;
ODBC_DEBUG_PRINTF_1("odbc_sql_func_exists\n");
ch = (SQLHDBC) s48_extract_integer(conn_handle);
fi = (SQLUSMALLINT) s48_extract_integer(fun_id);
retval = SQLGetFunctions(ch, fi, supported);
if (SQL_SUCCEEDED(retval))
return
s48_list_2(s48_enter_integer(retval),
SQL_FUNC_EXISTS(supported, fi) == SQL_TRUE ? S48_TRUE :
S48_FALSE);
else
return s48_list_2(s48_enter_integer(retval), S48_UNSPECIFIC);
}
/* Returns information about supported data types. */
s48_value odbc_sql_get_type_info(s48_value stmt_handle, s48_value data_type)
{
SQLHSTMT sh;
SQLSMALLINT dt;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_get_type_info\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
dt = (SQLSMALLINT) s48_extract_integer(data_type);
retval = SQLGetTypeInfo(sh, dt);
return s48_enter_integer(retval);
}
/*
*
* PART 3
*
* Setting and retrieving driver attributes
*
*/
s48_value odbc_sql_set_connect_attr_int(s48_value conn_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHDBC ch;
SQLINTEGER attr;
SQLUINTEGER val;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_set_connect_attr_int\n");
ch = (SQLHDBC) s48_extract_integer(conn_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLUINTEGER) s48_extract_integer(value);
retval = SQLSetConnectAttr(ch, attr, (SQLPOINTER) &val, 0);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLSetConnectAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_set_connect_attr_string(s48_value conn_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHDBC ch;
SQLINTEGER attr;
SQLCHAR *val;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_set_connect_attr_string\n");
ch = (SQLHDBC) s48_extract_integer(conn_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLCHAR *) s48_extract_string(value);
retval = SQLSetConnectAttr(ch, attr, val, S48_STRING_LENGTH(value));
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLSetConnectAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_get_connect_attr_string(s48_value conn_handle,
s48_value attribute)
{
#if (ODBCVER >= 0x300)
SQLHDBC ch;
SQLINTEGER attr;
SQLCHAR *buffer = NULL;
SQLINTEGER buffer_needed, buffer_len;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_connect_attr_string\n");
buffer_len = odbc_initial_retval_buffer_size;
for (;;) {
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetConnectAttr(ch, attr, buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_needed = buffer_len;
else
break;
}
res = s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_string(buffer) :
S48_UNSPECIFIC);
free(buffer);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLGetConnectAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_get_connect_attr_int(s48_value conn_handle,
s48_value attribute)
{
#if (ODBCVER >= 0x300)
SQLHDBC ch;
SQLINTEGER attr;
SQLUINTEGER buffer;
SQLINTEGER buffer_size;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_get_connect_attr_int\n");
retval = SQLGetConnectAttr(ch, attr,
&buffer, sizeof(SQLUINTEGER), &buffer_size);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(buffer) :
S48_UNSPECIFIC);
#else
RAISE_API_VERSION_MISMATCH("SQLGetConnectAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_set_env_attr_int(s48_value env_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHENV eh;
SQLINTEGER attr;
SQLUINTEGER val;
SQLRETURN retval;
eh = (SQLHENV) s48_extract_integer(env_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLUINTEGER) s48_extract_integer(value);
ODBC_DEBUG_PRINTF_4("odbc_sql_set_env_attr_int eh %x attr %d value %d\n", eh, attr, val);
retval = SQLSetEnvAttr(eh, attr, (SQLPOINTER) val, sizeof(SQLUINTEGER));
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLSetConnectAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_get_env_attr_int(s48_value env_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHENV eh;
SQLINTEGER attr;
SQLUINTEGER val, str_len;
SQLRETURN retval;
eh = (SQLHENV) s48_extract_integer(env_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLUINTEGER) s48_extract_integer(value);
ODBC_DEBUG_PRINTF_4("odbc_sql_get_env_attr_int eh %x attr %d value %d\n", eh, attr, val);
retval = SQLGetEnvAttr(eh, attr, &val, sizeof(SQLUINTEGER), &str_len);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(val) :
S48_UNSPECIFIC);
#else
RAISE_API_VERSION_MISMATCH("SQLGetEnvAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/* Sets a statement attribute */
s48_value odbc_sql_set_stmt_attr_int(s48_value stmt_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLINTEGER attr;
SQLUINTEGER val;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_get_stmt_attr_int\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLUINTEGER) s48_extract_integer(value);
retval = SQLSetStmtAttr(sh, attr, &val, 0);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLSetStmtAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_set_stmt_attr_string(s48_value stmt_handle,
s48_value attribute,
s48_value value)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLINTEGER attr;
SQLCHAR *val;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_set_stmt_attr_string\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
val = (SQLCHAR *) s48_extract_string(value);
retval = SQLSetStmtAttr(sh, attr, val, S48_STRING_LENGTH(value));
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLSetStmtAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_get_stmt_attr_int(s48_value stmt_handle, s48_value attribute)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLINTEGER attr, val, buf_size;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_get_stmt_attr_int\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
attr = (SQLINTEGER) s48_extract_integer(attribute);
retval = SQLGetStmtAttr(sh, attr, &val, sizeof(SQLINTEGER), &buf_size);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(val) :
S48_UNSPECIFIC);
#else
RAISE_API_VERSION_MISMATCH("SQLGetStmtAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
s48_value odbc_sql_get_stmt_attr_string(s48_value stmt_handle,
s48_value attribute)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLINTEGER attr, buffer_len, buffer_needed;
SQLCHAR *buffer = NULL;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(res);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_stmt_attr_string\n");
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetStmtAttr(sh, attr, &buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
res = s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_string(buffer) :
S48_UNSPECIFIC);
free(buffer);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLGetStmtAttr", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/*
*
* PART 4
*
* Setting and retrieving descriptor fields
*
*/
/* Returns the value of a single descriptor field (for integers) */
s48_value odbc_sql_get_desc_field_int(s48_value desc_handle, s48_value rec_number,
s48_value field_id)
{
#if (ODBCVER >= 0x300)
SQLHDESC dh;
SQLSMALLINT rn, fi;
SQLINTEGER value, buffer_len;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value scheme_int = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, scheme_int);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_desc_field_int\n");
dh = (SQLHDESC) s48_extract_integer(desc_handle);
rn = (SQLSMALLINT) s48_extract_integer(rec_number);
fi = (SQLSMALLINT) s48_extract_integer(field_id);
retval = SQLGetDescField(dh, rn, fi, (SQLPOINTER) &value,
sizeof(SQLINTEGER), &buffer_len);
if (SQL_SUCCEEDED(retval))
switch (buffer_len)
{
case SQL_IS_INTEGER:
scheme_int = s48_enter_integer((SQLINTEGER) value);
break;
case SQL_IS_UINTEGER:
scheme_int = s48_enter_integer((SQLUINTEGER) value);
break;
case SQL_IS_SMALLINT:
scheme_int = s48_enter_integer((SQLSMALLINT) value);
break;
case SQL_IS_USMALLINT:
scheme_int = s48_enter_integer((SQLUSMALLINT) value);
break;
default:
RAISE_UNKNOWN_INTEGER_TYPE_ERROR("SQLGetDescField", buffer_len);
}
res = s48_list_2(s48_enter_integer(retval), scheme_int);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLGetDescField", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/* Returns the value of a single descriptor field (for strings/binary data) */
s48_value odbc_sql_get_desc_field_string(s48_value desc_handle, s48_value rec_number,
s48_value field_id)
{
#if (ODBCVER >= 0x300)
SQLHDESC dh;
SQLSMALLINT rn, fi;
SQLCHAR *buffer = NULL;
SQLINTEGER buffer_len, buffer_needed;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value scheme_str = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, scheme_str);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_desc_field_string\n");
dh = (SQLHDESC) s48_extract_integer(desc_handle);
rn = (SQLSMALLINT) s48_extract_integer(rec_number);
fi = (SQLSMALLINT) s48_extract_integer(field_id);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetDescField(dh, rn, fi, (SQLPOINTER) buffer,
buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
scheme_str = s48_enter_string(buffer);
free(buffer);
res = s48_list_2(s48_enter_integer(retval), scheme_str);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLGetDescField", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/*
*
* PART 5
*
* Preparing SQL requests
*
*/
/* Prepare a SQL statement for execution */
s48_value odbc_sql_prepare(s48_value stmt_handle, s48_value stmt_txt)
{
SQLHSTMT sh;
SQLCHAR *query;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_prepare\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
query = (SQLCHAR *) s48_extract_string(stmt_txt);
retval = SQLPrepare(sh, query, S48_STRING_LENGTH(stmt_txt));
return s48_enter_integer(retval);
}
s48_value odbc_sql_bind_parameter(s48_value bind_parameter_rec)
{
SQLHSTMT sh;
SQLUSMALLINT param_no;
SQLSMALLINT in_out_type, value_type, param_type, decimal_digits;
SQLUINTEGER column_size;
SQLPOINTER parameter_value_input_ptr, parameter_value_output_ptr;
SQLINTEGER buffer_length;
SQLRETURN retval;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(bind_parameter_rec);
sh = (SQLHSTMT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_STATEMENT_HANDLE));
param_no = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_PARAM_NO));
in_out_type = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_INPUT_OUTPUT_TYPE));
value_type = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_VALUE_TYPE));
param_type = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_PARAMETER_TYPE));
column_size = (SQLUINTEGER)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_COLUMN_SIZE));
decimal_digits = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_DECIMAL_DIGITS));
buffer_length = (SQLINTEGER)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_BUFFER_LENGTH));
parameter_value_input_ptr = (SQLPOINTER)
s48_extract_integer(S48_RECORD_REF(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_PARAMETER_VALUE_INPUT_PTR));
if ((in_out_type == SQL_PARAM_INPUT_OUTPUT) || (in_out_type == SQL_PARAM_OUTPUT))
parameter_value_output_ptr = (SQLPOINTER) malloc(buffer_length);
else
parameter_value_output_ptr = NULL;
S48_RECORD_SET(bind_parameter_rec,
SR_ODBC_BIND_PARAMETER_PARAMETER_VALUE_OUTPUT_PTR,
s48_enter_integer((long) parameter_value_output_ptr));
/* retval = SQLBindParameter(sh, param_no, in_out_type, value_type, */
/* param_type, column_size, decimal_digits, */
/* param_type); */
S48_GC_UNPROTECT();
}
s48_value bind_parameter_set_buffer(s48_value bind_parameter_rec, s48_value value)
{
return S48_UNSPECIFIC;
}
s48_value bind_parameter_get_buffer(s48_value bind_parameter_rec)
{
return S48_UNSPECIFIC;
}
s48_value odbc_sql_get_cursor_name(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
SQLCHAR *buffer = NULL;
SQLSMALLINT buffer_len, buffer_needed;
s48_value res = S48_UNSPECIFIC;
s48_value scheme_str = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, scheme_str);
ODBC_DEBUG_PRINTF_1("odbc_sql_get_cursor_name\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetCursorName(sh, buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
scheme_str = s48_enter_string(buffer);
free(buffer);
res = s48_list_2(s48_enter_integer(retval), scheme_str);
S48_GC_UNPROTECT();
return res;
}
s48_value odbc_sql_set_cursor_name(s48_value stmt_handle, s48_value cursorname)
{
SQLHSTMT sh;
SQLCHAR *cn;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_set_cursor_name\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLCHAR *) s48_extract_string(cursorname);
retval = SQLSetCursorName(sh, cn, S48_STRING_LENGTH(cursorname));
return s48_enter_integer(retval);
}
/*
*
* PART 6
*
* Submitting requests
*
*/
s48_value odbc_sql_execute(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_execute\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
retval = SQLExecute(sh);
return s48_enter_integer(retval);
}
s48_value odbc_sql_execute_direct(s48_value stmt_handle,
s48_value stmt)
{
SQLHSTMT sh;
SQLCHAR *query;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_execute_direct\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
query = (SQLCHAR *) s48_extract_string(stmt);
retval = SQLExecDirect(sh, query, S48_STRING_LENGTH(stmt));
return s48_enter_integer(retval);
}
/* Returns the text of an SQL statement as translated by the driver. */
s48_value odbc_sql_native_sql(s48_value conn_handle, s48_value stmt_txt)
{
SQLHDBC ch;
SQLCHAR *stmt_in, *stmt_out = NULL;
SQLINTEGER buffer_len, buffer_needed;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value scheme_str = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, scheme_str);
ch = (SQLHDBC) s48_extract_integer(conn_handle);
stmt_in = (SQLCHAR *) s48_extract_string(stmt_txt);
ODBC_DEBUG_PRINTF_1("odbc_sql_native_sql\n");
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &stmt_out, buffer_len, sizeof(SQLCHAR));
retval = SQLNativeSql(ch, stmt_in, S48_STRING_LENGTH(stmt_txt),
stmt_out, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && buffer_needed > buffer_len)
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
scheme_str = s48_enter_string(stmt_out);
free(stmt_out);
res = s48_list_2(s48_enter_integer(retval), scheme_str);
S48_GC_UNPROTECT();
return res;
}
/* Returns the description for a specific parameter in a statement */
s48_value odbc_sql_describe_param(s48_value stmt_handle, s48_value parameter_no)
{
SQLHSTMT sh;
SQLUSMALLINT pn;
SQLUINTEGER ps;
SQLSMALLINT dt, dd, n;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value scheme_rec = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, scheme_rec);
ODBC_DEBUG_PRINTF_1("odbc_sql_describe_param\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
pn = (SQLUSMALLINT) s48_extract_integer(parameter_no);
retval = SQLDescribeParam(sh, pn, &dt, &ps, &dd, &n);
if (SQL_SUCCEEDED(retval))
{
scheme_rec = s48_make_record(odbc_parameter_record_type);
S48_RECORD_SET(scheme_rec, SR_ODBC_PARAMETER_TYPE, s48_enter_integer(dt));
S48_RECORD_SET(scheme_rec, SR_ODBC_PARAMETER_SIZE, s48_enter_integer(ps));
S48_RECORD_SET(scheme_rec, SR_ODBC_PARAMETER_DIGITS, s48_enter_integer(dd));
S48_RECORD_SET(scheme_rec, SR_ODBC_PARAMETER_NULLABLE, s48_enter_integer(n));
}
res = s48_list_2(s48_enter_integer(retval), scheme_rec);
S48_GC_UNPROTECT();
return res;
}
/* Returns the number of parameters in a statement */
s48_value odbc_sql_num_params(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLSMALLINT params;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_num_params\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
retval = SQLNumParams(sh, &params);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(params) :
S48_UNSPECIFIC);
}
/*
*
* PART 7
*
* Retrieving results and information about results
*
*/
s48_value odbc_sql_row_count(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
SQLINTEGER rowcount;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
ODBC_DEBUG_PRINTF_1("odbc_sql_row_count\n");
retval = SQLRowCount(sh, &rowcount);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(rowcount) :
S48_UNSPECIFIC);
}
s48_value odbc_sql_get_data(s48_value stmt_handle, s48_value column_number,
s48_value target_type)
{
SQLHSTMT sh;
SQLUSMALLINT cn;
SQLSMALLINT tt, buffer_len;
SQLINTEGER buffer_needed;
SQLRETURN retval;
void *buffer = NULL;
s48_value result = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(result);
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLUSMALLINT) s48_extract_integer(column_number);
tt = (SQLSMALLINT) s48_extract_integer(target_type);
ODBC_DEBUG_PRINTF_4("odbc_sql_get_data() sh:%x cn:%d tt:%d\n", sh, cn, tt);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof_sql_c_type_identifier(tt));
retval = SQLGetData(sh, cn, tt, buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
{
result = s48_list_2(s48_enter_integer(retval), buffer_to_s48_value(buffer, tt));
free(buffer);
}
else
result = s48_list_2(s48_enter_integer(retval), S48_UNSPECIFIC);
S48_GC_UNPROTECT();
return result;
}
/* Positions a cursor within a fetched block of data and allows an application
to refresh data in the rowset or to update or delete data in the result
set */
s48_value odbc_sql_set_pos(s48_value stmt_handle, s48_value row_number,
s48_value operation, s48_value lock_type)
{
SQLHSTMT sh;
SQLUSMALLINT rn, op, lt;
SQLRETURN retval;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
rn = (SQLUSMALLINT) s48_extract_integer(row_number);
op = (SQLUSMALLINT) s48_extract_integer(operation);
lt = (SQLUSMALLINT) s48_extract_integer(lock_type);
ODBC_DEBUG_PRINTF_5("odbc_sql_set_pos() sh:%x rn:%d op:%d lt:%d\n", sh, rn, op, lt);
retval = SQLSetPos(sh, rn, op, lt);
return s48_enter_integer(retval);
}
/* Performs bulk insertions and bulk bookmark operations, including
update, delete, and fetch by bookmark. */
s48_value odbc_sql_bulk_operations(s48_value stmt_handle, s48_value operation)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLUSMALLINT op;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_bulk_operations\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
op = (SQLUSMALLINT) s48_extract_integer(operation);
retval = SQLBulkOperations(sh, op);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLBulkOperations", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/* Determines whether there are more result sets available and, if so,
initializes processing for the next result set */
s48_value odbc_sql_more_results(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_more_results\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
retval = SQLMoreResults(sh);
return s48_enter_integer(retval);
}
s48_value odbc_sql_fetch(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
ODBC_DEBUG_PRINTF_2("odbc_sql_fetch() %x\n", sh);
retval = SQLFetch(sh);
return s48_enter_integer(retval);
}
s48_value odbc_sql_num_result_cols(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLSMALLINT numcols;
SQLRETURN retval;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
ODBC_DEBUG_PRINTF_1("odbc_sql_num_result_cols\n");
retval = SQLNumResultCols(sh, &numcols);
return s48_list_2(s48_enter_integer(retval),
SQL_SUCCEEDED(retval) ? s48_enter_integer(numcols) :
S48_UNSPECIFIC);
}
s48_value odbc_sql_describe_col(s48_value stmt_handle, s48_value column_number)
{
SQLHSTMT sh;
SQLSMALLINT cn;
SQLCHAR *buffer = NULL;
SQLSMALLINT buffer_len, buffer_needed, data_type, digits, nullable;
SQLUINTEGER col_size;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value col_rec = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(2);
S48_GC_PROTECT_2(res, col_rec);
ODBC_DEBUG_PRINTF_1("odbc_sql_describe_col\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLSMALLINT) s48_extract_integer(column_number);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLDescribeCol(sh, cn,
buffer, buffer_len, &buffer_needed,
&data_type, &col_size, &digits,
&nullable);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
{
col_rec = s48_make_record(odbc_column_record_type);
S48_RECORD_SET(col_rec, SR_ODBC_COLUMN_NAME,
s48_enter_string(buffer));
S48_RECORD_SET(col_rec, SR_ODBC_COLUMN_TYPE,
s48_enter_integer(data_type));
S48_RECORD_SET(col_rec, SR_ODBC_COLUMN_SIZE,
s48_enter_integer(col_size));
S48_RECORD_SET(col_rec, SR_ODBC_COLUMN_DIGITS,
s48_enter_integer(digits));
S48_RECORD_SET(col_rec, SR_ODBC_COLUMN_NULLABLE,
s48_enter_integer(nullable));
}
res = s48_list_2(s48_enter_integer(retval), col_rec);
free(buffer);
S48_GC_UNPROTECT();
return res;
}
/* Describes attributes of a column in the result set */
s48_value odbc_sql_col_attribute(s48_value stmt_handle, s48_value column_number,
s48_value field_id)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLUSMALLINT cn, fi;
SQLCHAR *buffer = NULL;
SQLSMALLINT buffer_len, buffer_needed;
SQLINTEGER intbuffer;
SQLRETURN retval;
s48_value res_string = S48_UNSPECIFIC;
s48_value res_pair = S48_UNSPECIFIC;
s48_value res = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(res, res_pair, res_string);
ODBC_DEBUG_PRINTF_1("odbc_sql_col_attribute\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLUSMALLINT) s48_extract_integer(column_number);
fi = (SQLUSMALLINT) s48_extract_integer(field_id);
buffer_len = odbc_initial_retval_buffer_size;
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLColAttribute(sh, cn, fi,
buffer, buffer_len, &buffer_needed,
&intbuffer);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
buffer_len = buffer_needed+1;
else
break;
}
if (SQL_SUCCEEDED(retval))
{
res_string = s48_enter_string(buffer);
res_pair = s48_cons(res_string, s48_enter_integer(intbuffer));
}
free(buffer);
res = s48_list_2(s48_enter_integer(retval), res_pair);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLColAttribute", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
ColumnRecPtr bindcol_lookup_binding(SQLHSTMT stmt_handle, SQLUSMALLINT column_no)
{
StmtRecPtr stmt;
ColumnRecPtr col;
ODBC_DEBUG_PRINTF_3("bindcol_lookup_binding() %x %d\n", stmt_handle, column_no);
stmt = global_bindcol_list;
while (stmt != NULL)
{
if (stmt->stmt_handle == stmt_handle)
{
col = stmt->col_recs;
while ((col != NULL) && (col->col_no != column_no))
col = col->next;
return col;
}
col = col->next;
}
return NULL;
}
s48_value bindcol_lookup_binding_scheme(s48_value stmt_handle, s48_value column_no)
{
SQLHSTMT sh;
SQLUSMALLINT cn;
ColumnRecPtr col;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLUSMALLINT) s48_extract_integer(column_no);
ODBC_DEBUG_PRINTF_3("bindcol_lookup_binding_scheme() sh:%x cn:%d\n", sh, cn);
col = bindcol_lookup_binding(sh, cn);
if (col == NULL)
RAISE_ODBC_BINDCOL_UNBOUND_COLUMN_ERROR((long)sh, cn)
else
{
ODBC_DEBUG_PRINTF_2("bindcol_lookup_binding_scheme(): col_buf:%x\n", col->col_buffer);
return buffer_to_s48_value(col->col_buffer, col->target_type);
}
}
/* Semantics differs from original SQLBindCol(), due to the need of
bookkeeping a target buffer list in C. odbc_sql_bindcol() handles
column binding and rebinding, but not unbinding. To unbind a column
use bindcol_unbind_column() or bindcol_finalize_bindcols(). */
s48_value odbc_sql_bindcol(s48_value stmt_handle, s48_value column_no,
s48_value target_type, s48_value buffer_len)
{
SQLHSTMT sh;
SQLUSMALLINT cn;
SQLSMALLINT tt;
SQLLEN bl;
SQLRETURN retval;
ColumnRecPtr col = NULL;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
cn = (SQLUSMALLINT) s48_extract_integer(column_no);
tt = (SQLSMALLINT) s48_extract_integer(target_type);
bl = (SQLLEN) s48_extract_integer(buffer_len);
ODBC_DEBUG_PRINTF_5("odbc_sql_bindcol() %x %d %d %d\n", sh, cn, tt, bl);
/* try to look up ColumRec */
col = bindcol_lookup_binding(sh, cn);
if (col == NULL)
{
/* There is no binding for this stmt-handle/column-no yet */
ODBC_DEBUG_PRINTF_1("odbc_sql_bindcol(): new binding\n");
col = (ColumnRec *) malloc(sizeof(ColumnRec));
if (col == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(ColumnRec));
/* initialize it */
col->col_no = cn;
col->target_type = tt;
col->buffer_len = bl;
col->buffer_needed = 0;
col->next = NULL;
col->col_buffer = (void *) malloc(sizeof_sql_c_type_identifier(tt)*bl);
ODBC_DEBUG_PRINTF_3("odbc_sql_bindcol() malloc %x %d\n",
col->col_buffer, sizeof_sql_c_type_identifier(tt)*bl);
if (col->col_buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof_sql_c_type_identifier(tt)*bl);
/* store col in global_bindcol_list */
bindcol_bind_column(sh, cn, col);
}
else
{
/* user wishes to rebind column for whatever reason */
ODBC_DEBUG_PRINTF_1("odbc_sql_bindcol(): rebinding existing binding\n");
if (tt != col->target_type)
RAISE_ODBC_BINDCOL_REBINDING_ERROR("While rebinding buffers: old/new target type do not match")
/* free the old buffer, allocate a new one */
free(col->col_buffer);
col->col_buffer = (void *) malloc(sizeof_sql_c_type_identifier(tt)*bl);
col->buffer_len = sizeof_sql_c_type_identifier(tt)*bl;
ODBC_DEBUG_PRINTF_3("odbc_sql_bindcol() reallocate %x %d\n", col->col_buffer,
sizeof_sql_c_type_identifier(tt)*bl);
if (col->col_buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof_sql_c_type_identifier(tt)*bl);
}
/* at this point ColumRecPtr col has been created or updated, call SQLBindCol() */
retval = SQLBindCol(sh, cn, tt, col->col_buffer, col->buffer_len, &col->buffer_needed);
return s48_enter_integer(retval);
}
void bindcol_bind_column(SQLHSTMT stmt_handle, SQLUSMALLINT column_no, ColumnRecPtr new_col)
{
StmtRecPtr stmt, prev_stmt, new_stmt;
ColumnRecPtr col, prev_col;
ODBC_DEBUG_PRINTF_4("bindcol_bind_column() %x %d %x\n", stmt_handle, column_no, new_col);
prev_stmt = stmt = global_bindcol_list;
while (stmt != NULL)
{
if (stmt->stmt_handle == stmt_handle)
{
prev_col = col = stmt->col_recs;
while ((col != NULL) && (col->col_no != column_no))
{
prev_col = col;
col = col->next;
}
if (col == NULL)
{
prev_col->next = new_col;
return;
}
}
prev_stmt = stmt;
stmt = stmt->next;
}
if (stmt == NULL)
{
ODBC_DEBUG_PRINTF_1("bindcol_bind_column() global_bindcol_list is empty\n");
new_stmt = (StmtRecPtr) malloc(sizeof(StmtRec));
if (new_stmt == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(StmtRec));
new_stmt->next = NULL;
new_stmt->stmt_handle = stmt_handle;
new_stmt->col_recs = new_col;
if (global_bindcol_list == NULL)
global_bindcol_list = new_stmt;
else
prev_stmt->next = new_stmt;
}
}
void bindcol_unbind_colum(SQLHSTMT stmt_handle, SQLUSMALLINT column_no)
{
StmtRecPtr stmt, prev_stmt;
ColumnRecPtr col, prev_col;
ODBC_DEBUG_PRINTF_3("bindcol_unbind_colum() %x %d\n", stmt_handle, column_no);
prev_stmt = stmt = global_bindcol_list;
while (stmt != NULL)
{
if (stmt->stmt_handle == stmt_handle)
{
prev_col = col = stmt->col_recs;
while ((col != NULL) && (col->col_no != column_no))
{
prev_col = col;
col = col->next;
}
if (col == NULL)
RAISE_ODBC_BINDCOL_UNBOUND_COLUMN_ERROR((long)stmt_handle, column_no)
ODBC_DEBUG_PRINTF_2("bindcol_unbind_colum() free %x\n", col->col_buffer);
free(col->col_buffer);
prev_col->next = col->next;
free(col);
if (stmt->col_recs == NULL)
{
prev_stmt->next = stmt->next;
free(stmt);
}
return;
}
prev_stmt = stmt;
stmt = stmt->next;
}
RAISE_ODBC_BINDCOL_UNBOUND_COLUMN_ERROR((long)stmt_handle, column_no)
}
s48_value bindcol_finalize_bindcols(s48_value stmt_handle)
{
SQLHSTMT sh;
StmtRecPtr stmt, prev_stmt;
ColumnRecPtr col, prev_col, first_col;
SQLRETURN retval;
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
ODBC_DEBUG_PRINTF_2("bindcol_finalize_bindcols() %x\n", sh);
prev_stmt = stmt = global_bindcol_list;
while (stmt != NULL)
{
if (stmt->stmt_handle == sh)
{
/* a rather dumb approach... */
first_col = stmt->col_recs;
while (first_col != NULL)
{
col = first_col;
while (col != NULL)
{
if (col->next == NULL)
{
/* this bindcol_rec is the last in chain */
SQLLEN dummy;
retval = SQLBindCol(sh, col->col_no, col->target_type,
NULL, 0, &dummy);
free(col->col_buffer);
free(col);
prev_col->next = NULL;
}
prev_col = col;
col = col->next;
}
}
}
stmt = stmt->next;
}
return S48_UNSPECIFIC;
}
/*
*
* PART 8
*
* Obtaining information about the data source's
* system tables (catalog functxbions)
*
*/
/* Returns a list of columns and associated privileges for one or more tables */
s48_value odbc_sql_column_privileges(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name,
s48_value column_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table, *column;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_column_privileges\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
column = (SQLCHAR *) s48_extract_string(column_name);
retval = SQLColumnPrivileges(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name),
column, S48_STRING_LENGTH(column_name));
return s48_enter_integer(retval);
}
/* Returns the list of column names in a specified table */
s48_value odbc_sql_columns(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name,
s48_value column_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table, *column;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_columns\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
column = (SQLCHAR *) s48_extract_string(column_name);
retval = SQLColumns(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name),
column, S48_STRING_LENGTH(column_name));
return s48_enter_integer(retval);
}
/* Returns a list of columns names that make up foreign keys,
if the exist for a specified table */
s48_value odbc_sql_foreign_keys(s48_value stmt_handle, s48_value pk_catalog_name,
s48_value pk_schema_name, s48_value pk_table_name,
s48_value fk_catalog_name, s48_value fk_schema_name,
s48_value fk_table_name)
{
SQLHSTMT sh;
SQLCHAR *pk_catalog, *pk_schema, *pk_table;
SQLCHAR *fk_catalog, *fk_schema, *fk_table;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_foreign_keys\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
pk_catalog = (SQLCHAR *) s48_extract_string(pk_catalog_name);
pk_schema = (SQLCHAR *) s48_extract_string(pk_schema_name);
pk_table = (SQLCHAR *) s48_extract_string(pk_table_name);
fk_catalog = (SQLCHAR *) s48_extract_string(fk_catalog_name);
fk_schema = (SQLCHAR *) s48_extract_string(fk_schema_name);
fk_table = (SQLCHAR *) s48_extract_string(fk_table_name);
retval = SQLForeignKeys(sh,
pk_catalog, S48_STRING_LENGTH(pk_catalog_name),
pk_schema, S48_STRING_LENGTH(pk_schema_name),
pk_table, S48_STRING_LENGTH(pk_table_name),
fk_catalog, S48_STRING_LENGTH(fk_catalog_name),
fk_schema, S48_STRING_LENGTH(fk_schema_name),
fk_table, S48_STRING_LENGTH(fk_table_name));
return s48_enter_integer(retval);
}
/* Returns the list of column names that make up the primary key for a table */
s48_value odbc_sql_primary_keys(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_primary_keys\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
retval = SQLPrimaryKeys(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name));
return s48_enter_integer(retval);
}
/* Returns the list of input and output parameters, as well as the columns
that make up the result set for the specified procedures */
s48_value odbc_sql_procedure_columns(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value proc_name,
s48_value column_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *proc, *column;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_procedure_columns\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
proc = (SQLCHAR *) s48_extract_string(proc_name);
column = (SQLCHAR *) s48_extract_string(column_name);
retval = SQLProcedureColumns(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
proc, S48_STRING_LENGTH(proc_name),
column, S48_STRING_LENGTH(column_name));
return s48_enter_integer(retval);
}
/* Returns the list of procedure names stored in a specific data source. */
s48_value odbc_sql_procedures(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value proc_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *proc;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_procedures\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
proc = (SQLCHAR *) s48_extract_string(proc_name);
retval = SQLProcedures(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
proc, S48_STRING_LENGTH(proc_name));
return s48_enter_integer(retval);
}
/* Returns information about the optimal set of columns that uniquely identifies
a row in a specified table, or the columns that are automatically updated
when any value in the row is updated by a transaction */
s48_value odbc_sql_special_columns(s48_value stmt_handle, s48_value identifier_type,
s48_value catalog_name, s48_value schema_name,
s48_value table_name, s48_value scope,
s48_value nullable)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table;
SQLSMALLINT s, n, it;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_special_columns\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
it = (SQLSMALLINT) s48_extract_integer(identifier_type);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
s = (SQLSMALLINT) s48_extract_integer(scope);
n = (SQLSMALLINT) s48_extract_integer(nullable);
retval = SQLSpecialColumns(sh, it,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name),
s, n);
return s48_enter_integer(retval);
}
/* Returns statistics about a single table and the list of indexes associated
with the table */
s48_value odbc_sql_statistics(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name,
s48_value unique, s48_value reserved)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table;
SQLSMALLINT u, r;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_statistics\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
u = (SQLSMALLINT) s48_extract_integer(unique);
r = (SQLSMALLINT) s48_extract_integer(reserved);
retval = SQLStatistics(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name),
u, r);
return s48_enter_integer(retval);
}
/* Returns a list of tables and the privileges associated with each table */
s48_value odbc_sql_table_privileges(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *table;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_table_privileges\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
catalog = (SQLCHAR *) s48_extract_string(catalog_name);
schema = (SQLCHAR *) s48_extract_string(schema_name);
table = (SQLCHAR *) s48_extract_string(table_name);
retval = SQLTablePrivileges(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
table, S48_STRING_LENGTH(table_name));
return s48_enter_integer(retval);
}
/* Returns the list of table names stored in a specific data source */
s48_value odbc_sql_tables(s48_value stmt_handle, s48_value catalog_name,
s48_value schema_name, s48_value table_name,
s48_value table_type)
{
SQLHSTMT sh;
SQLCHAR *catalog, *schema, *tablen, *tablet;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_tables\n");
retval = SQLTables(sh,
catalog, S48_STRING_LENGTH(catalog_name),
schema, S48_STRING_LENGTH(schema_name),
tablen, S48_STRING_LENGTH(table_name),
tablet, S48_STRING_LENGTH(table_type));
return s48_enter_integer(retval);
}
/*
*
* PART 9
*
* Terminating a statement
*
*/
/* Ends statement processing, discards pending resilt, and,
* optionally, frees all resources associated with the
* statement handle */
s48_value odbc_sql_free_statement(s48_value stmt_handle, s48_value option)
{
SQLHSTMT sh;
SQLUSMALLINT opt;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_free_statement\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
opt = (SQLUSMALLINT) s48_extract_integer(option);
retval = SQLFreeStmt(sh, opt);
return s48_enter_integer(retval);
}
/* Closes a cursor that has been opened on a statement handle */
s48_value odbc_sql_close_cursor(s48_value stmt_handle)
{
#if (ODBCVER >= 0x300)
SQLHSTMT sh;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_close_cursor\n");
sh = (SQLHSTMT) s48_extract_integer(stmt_handle);
retval = SQLCloseCursor(sh);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLCloseCursor", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/* Cancels an SQL statement */
s48_value odbc_sql_cancel(s48_value stmt_handle)
{
SQLHSTMT sh;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_cancel\n");
retval = SQLCancel(sh);
return s48_enter_integer(retval);
}
/* Commits or rolls back a transaction */
s48_value odbc_sql_endtran(s48_value handle_type, s48_value handle,
s48_value completion_type)
{
#if (ODBCVER >= 0x300)
SQLSMALLINT ht, ct;
SQLHANDLE h;
SQLRETURN retval;
ODBC_DEBUG_PRINTF_1("odbc_sql_endtran\n");
ht = (SQLSMALLINT) s48_extract_integer(handle_type);
h = (SQLHANDLE) s48_extract_integer(handle);
ct = (SQLSMALLINT) s48_extract_integer(completion_type);
retval = SQLEndTran(ht, h, ct);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLEndTran", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/*
*
* PART 10
*
* Terminating a connection
*
*/
/* Closes the connection */
s48_value odbc_sql_disconnect(s48_value conn_handle)
{
SQLHDBC ch;
SQLRETURN retval;
ch = (SQLHDBC) s48_extract_integer(conn_handle);
ODBC_DEBUG_PRINTF_2("odbc_sql_disconnect() %x\n", ch);
retval = SQLDisconnect(ch);
return s48_enter_integer(retval);
}
/* Free a handle */
s48_value odbc_sql_free_handle(s48_value handle_type, s48_value handle)
{
#if (ODBCVER >= 0x300)
SQLSMALLINT ht;
SQLHANDLE h;
SQLRETURN retval;
ht = (SQLSMALLINT) s48_extract_integer(handle_type);
h = (SQLHANDLE) s48_extract_integer(handle);
ODBC_DEBUG_PRINTF_3("odbc_sql_free_handle() %x %d\n", h, ht);
retval = SQLFreeHandle(ht, h);
return s48_enter_integer(retval);
#else
RAISE_API_VERSION_MISMATCH("SQLFreeHandle", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
/*
*
* PART 11
*
* misc. functions
*
*/
s48_value odbc_sql_get_diag_recs(s48_value handle_type, s48_value handle)
{
#if (ODBCVER >= 0x300)
SQLSMALLINT ht;
SQLHANDLE h;
SQLCHAR sql_state[6];
SQLINTEGER native_error;
SQLCHAR *buffer = NULL;
SQLSMALLINT i, more_recs, buffer_len, buffer_needed;
SQLRETURN retval;
s48_value res = S48_UNSPECIFIC;
s48_value rec_list = S48_NULL;
s48_value diag_rec = S48_UNSPECIFIC;
S48_DECLARE_GC_PROTECT(3);
S48_GC_PROTECT_3(res, rec_list, diag_rec);
ht = (SQLSMALLINT) s48_extract_integer(handle_type);
h = (SQLHANDLE) s48_extract_integer(handle);
ODBC_DEBUG_PRINTF_4("SQLGetDiagRec(%d, %x, %i)\n", ht, h, i);
i = more_recs = 1;
buffer_len = odbc_initial_retval_buffer_size;
while (more_recs) {
diag_rec = s48_make_record(odbc_diag_record_type);
for (;;)
{
odbc_sql_alloc((void **) &buffer, buffer_len, sizeof(SQLCHAR));
retval = SQLGetDiagRec(ht, h, i,
sql_state, &native_error,
buffer, buffer_len, &buffer_needed);
if (SQL_SUCCEEDED(retval) && (buffer_needed > buffer_len))
{
ODBC_DEBUG_PRINTF_3("buffer_needed %d buffer_len %d\n", buffer_needed, buffer_len);
buffer_len = buffer_needed+1;
}
else
break;
}
switch (retval)
{
case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO:
{
S48_RECORD_SET(diag_rec, SR_ODBC_DIAG_SQL_STATE, s48_enter_string(sql_state));
S48_RECORD_SET(diag_rec, SR_ODBC_DIAG_NATIVE_ERROR, s48_enter_integer(native_error));
S48_RECORD_SET(diag_rec, SR_ODBC_DIAG_MESSAGE, s48_enter_string(buffer));
rec_list = s48_cons(diag_rec, rec_list);
free(buffer);
buffer = NULL;
break;
}
case SQL_NO_DATA:
{
more_recs = 0;
break;
}
default:
{
free(buffer);
res = s48_list_2(s48_enter_integer(retval), S48_UNSPECIFIC);
S48_GC_UNPROTECT();
return res;
}
}
i++;
}
res = s48_list_2(s48_enter_integer(retval), rec_list);
free(buffer);
S48_GC_UNPROTECT();
return res;
#else
RAISE_API_VERSION_MISMATCH("SQLGetDiagRec", ODBCVER, 0x300);
#endif /* ODBCVER >= 0x300 */
}
#if ODBC_DEBUG_MSGS
/* print detailed debug information */
void odbc_debug_msgs(SQLSMALLINT handle_type, SQLHANDLE handle)
{
SQLCHAR sql_state[5];
SQLINTEGER native_error;
SQLCHAR message[ERROR_MSG_BUFFER_LEN];
SQLSMALLINT i, message_len;
SQLRETURN retval;
printf("fetching diag_rec from odbc driver.\n");
i = 1;
while (1) {
retval = SQLGetDiagRec(handle_type, handle,
i, sql_state,
&native_error,
message, ERROR_MSG_BUFFER_LEN-1,
&message_len);
if (retval == SQL_NO_DATA)
break;
if (retval == SQL_INVALID_HANDLE) {
printf("ODBC: Could not get debug information: invalid handle provided\n");
break;
}
if (retval == SQL_ERROR) {
printf("ODBC: SQLGetDiagRec returned SQL_ERROR\n");
break;
}
if (retval == SQL_SUCCESS_WITH_INFO)
printf("ODBC warning: error message buffer too small.\n");
if (retval == SQL_SUCCESS) {
printf("\nODBC status record %d:\n", i);
printf("SQL state: %s\n", (char *)sql_state);
/* TODO:
* Need to find out how to printf the
* native_error here
*/
printf("error msg: %s\n", message);
}
i++;
}
}
#endif
/* convert Scheme sql-date record to SQL_DATE_STRUCT */
void sql_date_record_to_struct(s48_value sql_date, SQL_DATE_STRUCT *ds)
{
ds->year = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_date, SR_SQL_DATE_YEAR));
ds->month = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_date, SR_SQL_DATE_MONTH));
ds->day = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_date, SR_SQL_DATE_DAY));
}
/* convert SQL_DATE_STRUCT to Scheme sql-date record */
s48_value struct_to_sql_date_record(SQL_DATE_STRUCT *ds)
{
s48_value sql_date;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(sql_date);
sql_date = s48_make_record(sql_date_record_type);
S48_RECORD_SET(sql_date, SR_SQL_DATE_YEAR,
s48_enter_integer(ds->year));
S48_RECORD_SET(sql_date, SR_SQL_DATE_MONTH,
s48_enter_integer(ds->month));
S48_RECORD_SET(sql_date, SR_SQL_DATE_DAY,
s48_enter_integer(ds->day));
S48_GC_UNPROTECT();
return sql_date;
}
/* convert Scheme sql-time record to SQL_TIME_STRUCT */
void sql_time_record_to_struct(s48_value sql_time, SQL_TIME_STRUCT *ts)
{
ts->hour = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_time, SR_SQL_TIME_HOUR));
ts->minute = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_time, SR_SQL_TIME_MINUTE));
ts->second = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_time, SR_SQL_TIME_SECOND));
}
/* convert SQL_TIME_STRUCT to Scheme sql-time record */
s48_value struct_to_sql_time_record(SQL_TIME_STRUCT *ts)
{
s48_value sql_time;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(sql_time);
sql_time = s48_make_record(sql_time_record_type);
S48_RECORD_SET(sql_time, SR_SQL_TIME_HOUR,
s48_extract_integer(ts->hour));
S48_RECORD_SET(sql_time, SR_SQL_TIME_MINUTE,
s48_extract_integer(ts->minute));
S48_RECORD_SET(sql_time, SR_SQL_TIME_SECOND,
s48_extract_integer(ts->second));
S48_GC_UNPROTECT();
return sql_time;
}
/* convert Scheme sql-timestamp record to SQL_TIMESTAMP_STRUCT */
void sql_timestamp_record_to_struct(s48_value sql_timestamp,
SQL_TIMESTAMP_STRUCT *ts)
{
ts->year = (SQLSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_YEAR));
ts->month = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_MONTH));
ts->day = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_DAY));
ts->hour = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_HOUR));
ts->minute = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_MINUTE));
ts->second = (SQLUSMALLINT)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_SECOND));
ts->fraction = (SQLUINTEGER)
s48_extract_integer(S48_RECORD_REF(sql_timestamp, SR_SQL_TIMESTAMP_FRACTION));
}
/* convert SQL_TIMESTAMP_STRUCT to Scheme sql-timestamp record */
s48_value struct_to_sql_timestamp_record(SQL_TIMESTAMP_STRUCT *ts)
{
s48_value sql_timestamp;
S48_DECLARE_GC_PROTECT(1);
S48_GC_PROTECT_1(sql_timestamp);
sql_timestamp = s48_make_record(sql_timestamp_record_type);
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_YEAR,
s48_extract_integer(ts->year));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_MONTH,
s48_extract_integer(ts->month));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_DAY,
s48_extract_integer(ts->day));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_HOUR,
s48_extract_integer(ts->hour));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_MINUTE,
s48_extract_integer(ts->minute));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_SECOND,
s48_extract_integer(ts->second));
S48_RECORD_SET(sql_timestamp, SR_SQL_TIMESTAMP_FRACTION,
s48_extract_integer(ts->fraction));
S48_GC_UNPROTECT();
return sql_timestamp;
}
/* gets a C type identifier and returns the size of this type,
according to Appendix D of ODBC Programmer's reference */
size_t sizeof_sql_c_type_identifier(SQLSMALLINT ctypeid)
{
switch (ctypeid)
{
case SQL_C_CHAR: return sizeof(SQLCHAR);
case SQL_C_SSHORT: case SQL_C_SHORT: return sizeof(SQLSMALLINT);
case SQL_C_USHORT: return sizeof(SQLUSMALLINT);
case SQL_C_SLONG: case SQL_C_LONG: return sizeof(SQLINTEGER);
case SQL_C_ULONG: return sizeof(SQLUINTEGER);
case SQL_C_FLOAT: return sizeof(SQLREAL);
case SQL_C_DOUBLE: return sizeof(SQLDOUBLE);
case SQL_C_BIT: return sizeof(SQLCHAR);
case SQL_C_STINYINT: return sizeof(SQLSCHAR);
case SQL_C_UTINYINT: return sizeof(SQLCHAR);
/* case SQL_SBIGINT: return sizeof(SQLBIGINT); */
/* case SQL_UBIGINT: return sizeof(SQLUBIGINT); */
case SQL_C_BINARY: return sizeof(SQLCHAR);
/* I don't know what to do with these types... */
/* case SQL_C_BOOKMARK: return sizeof(BOOKMARK); */
/* case SQL_C_VARBOOKMARK: return sizeof(SQLCHAR); */
case SQL_C_TYPE_DATE: return sizeof(SQL_DATE_STRUCT);
case SQL_C_TYPE_TIME: return sizeof(SQL_TIME_STRUCT);
case SQL_C_TYPE_TIMESTAMP: return sizeof(SQL_TIMESTAMP_STRUCT);
case SQL_C_NUMERIC: return sizeof(SQL_NUMERIC_STRUCT);
/* case SQL_C_GUID: return sizeof(SQLGUID); */
default:
RAISE_ODBC_UNKNOWN_C_TYPE_IDENTIFIER_ERROR(0, ctypeid);
break;
}
}
void odbc_sql_alloc(void **buffer, size_t buffer_len, size_t type_len)
{
ODBC_DEBUG_PRINTF_4("odbc_sql_alloc(): bf:%x bl:%d tl: %d\n", buffer, buffer_len, type_len);
if (*buffer == NULL)
{
ODBC_DEBUG_PRINTF_3("calloc bl:%d tl:%d\n", buffer_len+1, type_len);
*buffer = (void *) calloc(buffer_len+1, type_len);
}
else
{
ODBC_DEBUG_PRINTF_2("realloc bl:%d\n", buffer_len*type_len);
*buffer = (void *) realloc(*buffer, (buffer_len+1)*type_len);
}
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR((buffer_len+1)*type_len);
}
void copy_scheme_value_to_buffer(s48_value schemeval, void **buffer,
SQLSMALLINT ctypeid)
{
ODBC_DEBUG_PRINTF_3("s48_value_to_buffer(): ctypeid %d buffer %x\n",
ctypeid, buffer);
switch (ctypeid)
{
case SQL_C_CHAR:
*buffer = (void *)calloc(S48_STRING_LENGTH(schemeval)+1, sizeof(SQLCHAR));
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR((S48_STRING_LENGTH(schemeval)+1)*sizeof(SQLCHAR));
strcpy(*buffer, s48_extract_string(schemeval));
break;
case SQL_C_SSHORT: case SQL_C_SHORT: case SQL_C_USHORT:
/* SQL_C_SHORT has no default conversion, treat it like SQL_C_SHORT */
*buffer = (void *)malloc(sizeof(SQLSMALLINT));
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(SQLSMALLINT));
if (ctypeid == SQL_C_USHORT)
*((SQLSMALLINT *) *buffer) = (SQLUSMALLINT) s48_extract_unsigned_integer(schemeval);
else
*((SQLSMALLINT *) *buffer) = (SQLSMALLINT) s48_extract_integer(schemeval);
break;
case SQL_C_SLONG: case SQL_C_LONG: case SQL_C_ULONG:
/* SQL_C_LONG has no default conversion, treat it like SQL_C_LONG */
*buffer = (void *)malloc(sizeof(SQLINTEGER));
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(SQLINTEGER));
if (ctypeid == SQL_C_ULONG)
*((SQLUINTEGER *) *buffer) = (SQLUINTEGER) s48_extract_unsigned_integer(schemeval);
else
*((SQLINTEGER *) *buffer) = (SQLINTEGER) s48_extract_integer(schemeval);
break;
case SQL_C_FLOAT:
*buffer = (void *)malloc(sizeof(SQLREAL));
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(SQLREAL));
*((SQLREAL *) *buffer) = (SQLREAL) s48_extract_double(schemeval);
break;
case SQL_C_DOUBLE:
*buffer = (void *)malloc(sizeof(SQLDOUBLE));
if (*buffer == NULL)
RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(SQLDOUBLE));
*((SQLDOUBLE *) *buffer) = (SQLDOUBLE) s48_extract_double(schemeval);
break;
/* case SQL_C_TINYINT: case SQL_C_STINYINT: case SQL_C_UTINYINT: */
/* SQL_C_TINYINT has no default conversion, treat it like SQL_C_STINYINT */
/* *buffer = (void *)malloc(sizeof(SQLTINYINT)); */
/* if (*buffer == NULL) */
/* RAISE_ODBC_BUFFER_ALLOC_ERROR(sizeof(SQLTINYINT)); */
/* if (ctypeid == SQL_C_UTINYINT) */
/* *((SQLUTINYINT *) *buffer) = (SQLUTINYINT) s48_extract_unsigned_integer(schemeval); */
/* else */
/* *((SQLSTINYINT *) *buffer) = (SQLSTINYINT) s48_extract_integer(schemeval); */
/* break; */
default:
RAISE_ODBC_UNKNOWN_C_TYPE_IDENTIFIER_ERROR(NULL, ctypeid);
}
}
s48_value buffer_to_s48_value(void *buffer, SQLSMALLINT ctypeid)
{
ODBC_DEBUG_PRINTF_3("buffer_to_s48_value(): %x %d\n", buffer, ctypeid);
switch (ctypeid)
{
case SQL_C_CHAR:
return s48_enter_string((SQLCHAR *) buffer);
case SQL_C_SSHORT: case SQL_C_SHORT:
return s48_enter_integer(*((SQLSMALLINT*) buffer));
case SQL_C_USHORT:
return s48_enter_integer(*((SQLUSMALLINT*) buffer));
case SQL_C_SLONG: case SQL_C_LONG:
return s48_enter_integer(*((SQLINTEGER*) buffer));
case SQL_C_ULONG:
return s48_enter_integer(*((SQLUINTEGER*) buffer));
/* case SQL_C_FLOAT: */
/* case SQL_C_DOUBLE: */
/* case SQL_C_BIT: */
case SQL_C_STINYINT:
return s48_enter_integer(*((SQLSCHAR *) buffer));
case SQL_C_UTINYINT:
return s48_enter_integer(*((SQLCHAR *) buffer));
case SQL_C_BINARY:
return s48_enter_string((SQLCHAR *) buffer);
case SQL_C_TYPE_DATE:
return struct_to_sql_date_record((SQL_DATE_STRUCT *) buffer);
case SQL_C_TYPE_TIME:
return struct_to_sql_time_record((SQL_TIME_STRUCT *) buffer);
case SQL_C_TYPE_TIMESTAMP:
return struct_to_sql_timestamp_record((SQL_TIMESTAMP_STRUCT *) buffer);
/* case SQL_C_NUMERIC: */
default:
RAISE_ODBC_UNKNOWN_C_TYPE_IDENTIFIER_ERROR((long)buffer, ctypeid);
break;
}
}
/* set initial return value buffer size */
s48_value odbc_set_initial_retval_buffer_size(s48_value nobytes)
{
odbc_initial_retval_buffer_size = (SQLUSMALLINT) s48_extract_integer(nobytes);
}
/* get initial return value buffer size */
s48_value odbc_get_intial_retval_buffer_size()
{
return s48_enter_integer((int) odbc_initial_retval_buffer_size);
}
void s48_init_odbc(void)
{
/* bindings for record types */
S48_GC_PROTECT_GLOBAL(odbc_diag_record_type);
odbc_diag_record_type = s48_get_imported_binding("odbc-diag");
S48_GC_PROTECT_GLOBAL(odbc_column_record_type);
odbc_column_record_type = s48_get_imported_binding("odbc-column");
S48_GC_PROTECT_GLOBAL(odbc_parameter_record_type);
odbc_parameter_record_type = s48_get_imported_binding("odbc-parameter");
S48_GC_PROTECT_GLOBAL(odbc_bind_parameter_record_type);
odbc_bind_parameter_record_type = s48_get_imported_binding("odbc-bind-parameter");
S48_GC_PROTECT_GLOBAL(bindcol_buffer_record_type);
bindcol_buffer_record_type = s48_get_imported_binding("bindcol-buffer");
/* import conditions */
S48_GC_PROTECT_GLOBAL(raise_odbc_api_version_mismatch_error);
raise_odbc_api_version_mismatch_error
= s48_get_imported_binding("raise-odbc-api-version-mismatch-error");
S48_GC_PROTECT_GLOBAL(raise_odbc_unknown_integer_type_error);
raise_odbc_unknown_integer_type_error
= s48_get_imported_binding("raise-odbc-unknown-integer-type-error");
S48_GC_PROTECT_GLOBAL(raise_odbc_buffer_alloc_error);
raise_odbc_buffer_alloc_error
= s48_get_imported_binding("raise-odbc-buffer-alloc-error");
S48_GC_PROTECT_GLOBAL(raise_odbc_unknown_c_type_identifier_error);
raise_odbc_unknown_c_type_identifier_error
= s48_get_imported_binding("raise-odbc-unknown-c-type-identifier-error");
S48_GC_PROTECT_GLOBAL(raise_odbc_bindcol_unbound_column_error);
raise_odbc_bindcol_unbound_column_error
= s48_get_imported_binding("raise-odbc-bindcol-unbound-column-error");
S48_GC_PROTECT_GLOBAL(raise_odbc_bindcol_rebinding_error);
raise_odbc_bindcol_rebinding_error
= s48_get_imported_binding("raise-odbc-bindcol-rebinding-error");
/* init global variables */
global_bindcol_list = NULL;
/* functions for SQLBindCol() */
S48_EXPORT_FUNCTION(bindcol_lookup_binding_scheme);
S48_EXPORT_FUNCTION(odbc_sql_bindcol);
/* PART 1 */
S48_EXPORT_FUNCTION(odbc_alloc_environment_handle);
S48_EXPORT_FUNCTION(odbc_alloc_connection_handle);
S48_EXPORT_FUNCTION(odbc_alloc_statement_handle);
S48_EXPORT_FUNCTION(odbc_sql_connect);
S48_EXPORT_FUNCTION(odbc_sql_browse_connect);
/* PART 2 */
S48_EXPORT_FUNCTION(odbc_sql_data_sources);
S48_EXPORT_FUNCTION(odbc_sql_drivers);
S48_EXPORT_FUNCTION(odbc_sql_get_info_int);
S48_EXPORT_FUNCTION(odbc_sql_get_info_string);
S48_EXPORT_FUNCTION(odbc_sql_get_func_exists);
S48_EXPORT_FUNCTION(odbc_sql_get_type_info);
/* PART 3 */
S48_EXPORT_FUNCTION(odbc_sql_set_connect_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_set_connect_attr_string);
S48_EXPORT_FUNCTION(odbc_sql_get_connect_attr_string);
S48_EXPORT_FUNCTION(odbc_sql_get_connect_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_set_env_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_get_env_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_set_stmt_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_set_stmt_attr_string);
S48_EXPORT_FUNCTION(odbc_sql_get_stmt_attr_int);
S48_EXPORT_FUNCTION(odbc_sql_get_stmt_attr_string);
/* PART 4 */
S48_EXPORT_FUNCTION(odbc_sql_get_desc_field_int);
S48_EXPORT_FUNCTION(odbc_sql_get_desc_field_string);
/* PART 5 */
S48_EXPORT_FUNCTION(odbc_sql_prepare);
S48_EXPORT_FUNCTION(odbc_sql_bind_parameter);
S48_EXPORT_FUNCTION(bind_parameter_set_buffer);
S48_EXPORT_FUNCTION(bind_parameter_get_buffer);
S48_EXPORT_FUNCTION(odbc_sql_get_cursor_name);
S48_EXPORT_FUNCTION(odbc_sql_set_cursor_name);
/* PART 6 */
S48_EXPORT_FUNCTION(odbc_sql_execute);
S48_EXPORT_FUNCTION(odbc_sql_execute_direct);
S48_EXPORT_FUNCTION(odbc_sql_native_sql);
S48_EXPORT_FUNCTION(odbc_sql_describe_param);
S48_EXPORT_FUNCTION(odbc_sql_num_params);
/* PART 7 */
S48_EXPORT_FUNCTION(odbc_sql_row_count);
S48_EXPORT_FUNCTION(odbc_sql_get_data);
S48_EXPORT_FUNCTION(odbc_sql_set_pos);
S48_EXPORT_FUNCTION(odbc_sql_bulk_operations);
S48_EXPORT_FUNCTION(odbc_sql_more_results);
S48_EXPORT_FUNCTION(odbc_sql_fetch);
S48_EXPORT_FUNCTION(odbc_sql_num_result_cols);
S48_EXPORT_FUNCTION(odbc_sql_describe_col);
S48_EXPORT_FUNCTION(odbc_sql_col_attribute);
/* PART 8 */
S48_EXPORT_FUNCTION(odbc_sql_column_privileges);
S48_EXPORT_FUNCTION(odbc_sql_columns);
S48_EXPORT_FUNCTION(odbc_sql_foreign_keys);
S48_EXPORT_FUNCTION(odbc_sql_primary_keys);
S48_EXPORT_FUNCTION(odbc_sql_procedure_columns);
S48_EXPORT_FUNCTION(odbc_sql_procedures);
S48_EXPORT_FUNCTION(odbc_sql_special_columns);
S48_EXPORT_FUNCTION(odbc_sql_statistics);
S48_EXPORT_FUNCTION(odbc_sql_table_privileges);
S48_EXPORT_FUNCTION(odbc_sql_tables);
/* PART 9 */
S48_EXPORT_FUNCTION(odbc_sql_free_statement);
S48_EXPORT_FUNCTION(odbc_sql_close_cursor);
S48_EXPORT_FUNCTION(odbc_sql_cancel);
S48_EXPORT_FUNCTION(odbc_sql_endtran);
/* PART 10 */
S48_EXPORT_FUNCTION(odbc_sql_disconnect);
S48_EXPORT_FUNCTION(odbc_sql_free_handle);
/* PART 11 */
S48_EXPORT_FUNCTION(odbc_sql_get_diag_recs);
/* misc functions */
S48_EXPORT_FUNCTION(bindcol_finalize_bindcols);
S48_EXPORT_FUNCTION(odbc_set_initial_retval_buffer_size);
S48_EXPORT_FUNCTION(odbc_get_intial_retval_buffer_size);
}
Reference in New Issue View Git Blame Copy Permalink