/************************************************************************
* name: SQLGetDescRecW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLGetDescRecW (SQLHDESC hdesc, SQLSMALLINT record, SQLWCHAR *name,
SQLSMALLINT name_max, SQLSMALLINT *name_len, SQLSMALLINT *type,
SQLSMALLINT *subtype, SQLLEN *length, SQLSMALLINT *precision,
SQLSMALLINT *scale, SQLSMALLINT *nullable)
{
RETCODE ret = ODBC_ERROR;
SQLCHAR *name_buffer = NULL;
SQLSMALLINT name_buffer_len=0;
ODBC_DESC * desc_handle = hdesc;
OutputDebugString ("SQLDescribeColW called.\n");
name_buffer = UT_ALLOC (name_max);
if (name_buffer == NULL && name_max > 0)
{
odbc_set_diag (desc_handle->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (name_buffer, 0 , name_max);
ret = SQLGetDescRec(hdesc,
record, name_buffer, name_max,
&name_buffer_len, type, subtype,
length, precision, scale, nullable);
if (ret == ODBC_ERROR)
{
UT_FREE (name_buffer);
return ret;
}
bytes_to_wide_char (name_buffer, name_buffer_len, &name, name_max, (int*)name_len, NULL);
UT_FREE (name_buffer);
return ret;
}
/************************************************************************
* name: SQLDescribeColW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLDescribeColW (SQLHSTMT hstmt, SQLUSMALLINT column,
SQLWCHAR *name, SQLSMALLINT name_max, SQLSMALLINT *name_len,
SQLSMALLINT *type, SQLULEN *size, SQLSMALLINT *scale,
SQLSMALLINT *nullable)
{
RETCODE ret = ODBC_ERROR;
SQLCHAR *name_buffer = NULL;
SQLSMALLINT name_buffer_len=0;
ODBC_STATEMENT* stmt_handle = (ODBC_STATEMENT *) hstmt;
OutputDebugString ("SQLDescribeColW called.\n");
name_buffer = UT_ALLOC (name_max);
if (name_buffer == NULL && name_max > 0)
{
odbc_set_diag (stmt_handle->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (name_buffer, 0 , name_max);
ret = SQLDescribeCol(hstmt, column, name_buffer, name_max, &name_buffer_len, type, size, scale, nullable);
if (ret == ODBC_ERROR)
{
UT_FREE (name_buffer);
return ret;
}
bytes_to_wide_char (name_buffer, name_buffer_len, &name, name_max, (int*)name_len, NULL);
UT_FREE (name_buffer);
return ret;
}
/************************************************************************
* name: SQLGetDescFieldW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLGetDescFieldW (SQLHDESC hdesc, SQLSMALLINT record, SQLSMALLINT field,
SQLPOINTER value, SQLINTEGER value_max, SQLINTEGER *value_len)
{
RETCODE ret = ODBC_ERROR;
char* cb_value = NULL;
int cb_value_len = 0;
ODBC_DESC *DescriptorHandle = (ODBC_DESC*)hdesc;
OutputDebugString ("SQLGetDescFieldW called.\n");
cb_value = UT_ALLOC (value_max);
if (cb_value == NULL && value_max > 0)
{
odbc_set_diag (DescriptorHandle->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (cb_value, 0 , value_max);
SQLGetDescField(hdesc, record, field, cb_value, value_max, &cb_value_len);
if (ret == ODBC_ERROR)
{
UT_FREE (cb_value);
return ret;
}
bytes_to_wide_char (cb_value, cb_value_len, (wchar_t**)&value, value_max, (int*)value_len, NULL);
UT_FREE (cb_value);
return ret;
}
/************************************************************************
* name: SQLGetCursorNameW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLGetCursorNameW (SQLHSTMT hstmt, SQLWCHAR *cursor, SQLSMALLINT cursor_max,
SQLSMALLINT *cursor_len)
{
RETCODE ret = ODBC_ERROR;
char* cursor_name = NULL;
SQLSMALLINT cursor_name_len = 0;
ODBC_STATEMENT* stmt_handle = (ODBC_STATEMENT *) hstmt;
OutputDebugString ("SQLGetCursorNameW called.\n");
cursor_name = UT_ALLOC (cursor_max);
if (cursor_name == NULL && cursor_max > 0)
{
odbc_set_diag (stmt_handle->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (cursor_name, 0 , cursor_max);
ret = SQLGetCursorName(hstmt, cursor_name, cursor_max, &cursor_name_len);
if (ret == ODBC_ERROR)
{
UT_FREE (cursor_name);
return ret;
}
bytes_to_wide_char (cursor_name, cursor_name_len, &cursor, cursor_max, (int*)cursor_len, NULL);
UT_FREE(cursor_name);
return ret;
}
/************************************************************************
* name: SQLNativeSqlW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLNativeSqlW (SQLHDBC hdbc, SQLWCHAR *in, SQLINTEGER in_len,
SQLWCHAR *out, SQLINTEGER out_max, SQLINTEGER *out_len)
{
RETCODE ret = ODBC_ERROR;
SQLCHAR *sql_state, *sql_text_buffer = NULL;
int sql_state_len;
ODBC_CONNECTION * ConnectionHandle = (ODBC_CONNECTION *) hdbc;
OutputDebugString ("SQLNativeSqlW called.\n");
ret = wide_char_to_bytes (in, in_len, &sql_state, &sql_state_len, NULL);
sql_text_buffer = UT_ALLOC (out_max);
if (sql_text_buffer == NULL && out_max > 0)
{
odbc_set_diag (ConnectionHandle->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (sql_text_buffer, 0 , out_max);
ret = SQLNativeSql(hdbc, sql_state, sql_state_len, sql_text_buffer, out_max, out_len);
if (ret == ODBC_ERROR)
{
UT_FREE (sql_text_buffer);
return ret;
}
bytes_to_wide_char (sql_state, sql_state_len, &out, out_max, out_len, NULL);
UT_FREE (sql_text_buffer);
return ret;
}
/************************************************************************
* name: odbc_alloc_env
* arguments:
* ODBC_ENV **envptr
* returns/side-effects:
* RETCODE - odbc api return code
* description:
* NOTE:
************************************************************************/
PUBLIC RETCODE
odbc_alloc_env (ODBC_ENV ** envptr)
{
ODBC_ENV *env;
env = (ODBC_ENV *) UT_ALLOC (sizeof (ODBC_ENV));
if (env == NULL)
{
*envptr = (ODBC_ENV *) SQL_NULL_HENV;
return ODBC_ERROR;
}
else
{
memset (env, 0, sizeof (ODBC_ENV));
env->handle_type = SQL_HANDLE_ENV;
env->diag = odbc_alloc_diag ();
env->program_name = UT_MAKE_STRING ("ODBC", -1);
/* Default Attribute value */
env->attr_odbc_version = 0;
env->attr_connection_pooling = SQL_CP_DEFAULT;
env->attr_cp_match = SQL_CP_MATCH_DEFAULT;
env->attr_output_nts = SQL_TRUE;
env->next = odbc_environments;
odbc_environments = env;
*envptr = env;
}
return ODBC_SUCCESS;
}
/************************************************************************
* name: odbc_alloc_desc
* arguments:
* returns/side-effects:
* description:
* NOTE:
* con이 null이 아니면 con에 연결된 explicit desc로 간주한다.
************************************************************************/
PUBLIC RETCODE
odbc_alloc_desc (ODBC_CONNECTION * conn, ODBC_DESC ** desc_ptr)
{
ODBC_DESC *desc_node;
if (desc_ptr == NULL)
{
if (conn != NULL)
odbc_set_diag (conn->diag, "HY090", 0, NULL);
goto error;
}
desc_node = (ODBC_DESC *) UT_ALLOC (sizeof (ODBC_DESC));
if (desc_node == NULL)
{
if (conn != NULL)
odbc_set_diag (conn->diag, "HY001", 0, NULL);
goto error;
}
/* init members */
desc_node->handle_type = SQL_HANDLE_DESC;
desc_node->diag = odbc_alloc_diag ();
desc_node->stmt = NULL; /* set in odbc_alloc_stmt */
desc_node->conn = NULL;
desc_node->records = NULL;
desc_node->alloc_type = SQL_DESC_ALLOC_AUTO;
desc_node->array_size = 1;
desc_node->array_status_ptr = NULL;
desc_node->bind_offset_ptr = NULL;
desc_node->bind_type = SQL_BIND_BY_COLUMN; /* equal to SQL_PARAM_BY_COLUMN */
desc_node->max_count = 0;
desc_node->rows_processed_ptr = NULL;
/* for explicit */
if (conn != NULL)
{
desc_node->alloc_type = SQL_DESC_ALLOC_USER;
desc_node->next = conn->descriptors;
conn->descriptors = desc_node;
}
*desc_ptr = desc_node;
return ODBC_SUCCESS;
error:
return ODBC_ERROR;
}
/************************************************************************
* name: SQLGetDiagRecW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLGetDiagRecW (SQLSMALLINT HandleType,
SQLHANDLE Handle,
SQLSMALLINT RecNumber,
SQLWCHAR * Sqlstate,
SQLINTEGER * NativeError,
SQLWCHAR * MessageText,
SQLSMALLINT BufferLength, SQLSMALLINT * TextLength)
{
SQLCHAR *sql_state, *message_text_buffer = NULL;
int sql_state_len = 0;
SQLSMALLINT message_text_buffer_len = 0;
RETCODE ret;
ODBC_ENV *env;
env = (ODBC_ENV *) Handle;
OutputDebugString ("SQLGetDiagRecW called\n");
wide_char_to_bytes (Sqlstate, sqlwcharlen (Sqlstate), &sql_state, &sql_state_len, NULL);
message_text_buffer = UT_ALLOC (BufferLength);
if (message_text_buffer == NULL && BufferLength > 0)
{
odbc_set_diag (env->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (message_text_buffer, 0 , BufferLength);
ret = SQLGetDiagRec (HandleType, Handle, RecNumber, sql_state,
NativeError, message_text_buffer, BufferLength, &message_text_buffer_len);
if (ret == ODBC_ERROR)
{
UT_FREE (message_text_buffer);
return ret;
}
bytes_to_wide_char (message_text_buffer,
message_text_buffer_len,
&MessageText,
BufferLength,
(int*)TextLength,
NULL);
UT_FREE (message_text_buffer);
return ret;
}
/************************************************************************
* name: SQLDriverConnectW
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
ODBC_INTERFACE RETCODE SQL_API
SQLDriverConnectW (SQLHDBC hdbc, SQLHWND hwnd,
SQLWCHAR *in, SQLSMALLINT in_len,
SQLWCHAR *out, SQLSMALLINT out_max, SQLSMALLINT *out_len,
SQLUSMALLINT completion)
{
RETCODE rc = ODBC_SUCCESS;
SQLCHAR *pt_in, *pt_out;
int encode_len = 0, temp_out_len = 0;
ODBC_CONNECTION* conn = (ODBC_CONNECTION*)hdbc;
OutputDebugString ("SQLDriverConnectW called\n");
rc = wide_char_to_bytes (in, in_len, &pt_in, &encode_len, NULL);
if (rc != ODBC_SUCCESS)
{
odbc_set_diag (conn->diag, "HY001", 0, "encode failed");
return ODBC_ERROR;
}
pt_out = UT_ALLOC (out_max);
if (pt_out == NULL && out_max > 0)
{
odbc_set_diag (conn->diag, "HY001", 0, "malloc failed");
return ODBC_ERROR;
}
memset (pt_out, 0, out_max);
rc = SQLDriverConnect (
hdbc, hwnd,
pt_in, in_len,
pt_out, out_max, out_len,
completion);
if (out)
{
bytes_to_wide_char (pt_out, strlen (pt_out), &out, out_max, &temp_out_len, NULL);
}
if (out_len)
{
*out_len = temp_out_len;
}
UT_FREE (pt_in);
UT_FREE (pt_out);
return rc;
}
/************************************************************************
* name: odbc_alloc_record
* arguments:
* returns/side-effects:
* description:
* NOTE:
* record handle은 정의도 안 되었을뿐만 아니라, 외부에서 직접적으로 사용할
* 일이 없으므로 NULL을 허용한다.
* - error messaging
************************************************************************/
PUBLIC RETCODE
odbc_alloc_record (ODBC_DESC * desc, ODBC_RECORD ** rec, int rec_number)
{
ODBC_RECORD *rec_node;
if (desc == NULL)
{
goto error;
}
if (rec_number < 0)
{
goto error;
}
if (find_record_from_desc (desc, rec_number) != NULL)
{
/* alreay existing record */
goto error;
}
rec_node = (ODBC_RECORD *) UT_ALLOC (sizeof (ODBC_RECORD));
if (rec_node == NULL)
{
goto error;
}
if (rec_number > desc->max_count)
{
desc->max_count = rec_number;
}
/* init record members */
rec_node->auto_unique_value = SQL_FALSE;
rec_node->base_column_name = NULL;
rec_node->base_table_name = NULL;
rec_node->case_sensitive = SQL_FALSE;
rec_node->catalog_name = NULL;
rec_node->concise_type = SQL_C_DEFAULT;
rec_node->data_ptr = NULL;
rec_node->datetime_interval_code = 0;
rec_node->datetime_interval_precision = 0;
rec_node->display_size = 0;
rec_node->fixed_prec_scale = SQL_FALSE;
rec_node->indicator_ptr = NULL;
rec_node->length = 0; /* ??? */
rec_node->literal_prefix = NULL;
rec_node->literal_suffix = NULL;
rec_node->local_type_name = NULL;
rec_node->name = NULL;
rec_node->nullable = SQL_NULLABLE_UNKNOWN;
rec_node->num_prec_radix = 0;
rec_node->octet_length = 0;
rec_node->octet_length_ptr = NULL;
rec_node->parameter_type = SQL_PARAM_INPUT;
rec_node->precision = 0;
rec_node->rowver = SQL_FALSE;
rec_node->schema_name = NULL;
rec_node->searchable = SQL_PRED_NONE;
rec_node->table_name = NULL;
rec_node->type = SQL_C_DEFAULT;
rec_node->type_name = NULL;
rec_node->unnamed = SQL_UNNAMED;
rec_node->unsigned_type = SQL_FALSE;
rec_node->updatable = SQL_ATTR_READWRITE_UNKNOWN;
rec_node->record_number = rec_number;
rec_node->desc = desc;
rec_node->next = desc->records;
desc->records = rec_node;
if (rec != NULL)
{
*rec = rec_node;
}
return ODBC_SUCCESS;
error:
return ODBC_ERROR;
}
