/************************************************************************
* 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: 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: 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: 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: 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_get_env_attr
* arguments:
* ODBC_ENV *env
* returns/side-effects:
* RETCODE - odbc api return code
* description:
* NOTE:
************************************************************************/
PUBLIC
odbc_get_env_attr (ODBC_ENV * env,
long attribute,
void *value_ptr,
long buffer_length, long *string_length_ptr)
{
switch (attribute)
{
case SQL_ATTR_ODBC_VERSION:
if (value_ptr != NULL)
*((unsigned long *) value_ptr) = env->attr_odbc_version;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (long);
break;
case SQL_ATTR_OUTPUT_NTS:
if (value_ptr != NULL)
*((unsigned long *) value_ptr) = env->attr_output_nts;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (long);
break;
default:
odbc_set_diag (env->diag, "HY092", 0, NULL);
return ODBC_ERROR;
}
return ODBC_SUCCESS;
}
/************************************************************************
* name: odbc_set_desc_rec
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
PUBLIC RETCODE
odbc_set_desc_rec (ODBC_DESC * desc,
SQLSMALLINT rec_number,
SQLSMALLINT type,
SQLSMALLINT subtype,
SQLLEN length,
SQLSMALLINT precision,
SQLSMALLINT scale,
SQLPOINTER data_ptr,
SQLLEN *string_length_ptr, SQLLEN *indicator_ptr)
{
/* ODBC_RECORD *record; */
short concise_type;
ODBC_RECORD *record;
record = find_record_from_desc (desc, rec_number);
if (record == NULL)
{
odbc_set_diag (desc->diag, "07009", 0, NULL);
return ODBC_NO_DATA;
}
odbc_set_desc_field (desc, rec_number, SQL_DESC_TYPE,
(void *) type, sizeof (type), 1);
if (subtype == SQL_DATETIME || subtype == SQL_INTERVAL)
{
odbc_set_desc_field (desc, rec_number, SQL_DESC_DATETIME_INTERVAL_CODE,
(void *) subtype, sizeof (subtype), 1);
}
concise_type = odbc_verbose_to_concise_type (type, subtype);
odbc_set_desc_field (desc, rec_number, SQL_DESC_CONCISE_TYPE,
(void *) concise_type, sizeof (concise_type), 1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_OCTET_LENGTH,
(void *) length, sizeof (length), 1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_PRECISION,
(void *) precision, sizeof (precision), 1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_SCALE,
(void *) scale, sizeof (scale), 1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_DATA_PTR,
(void *) data_ptr, sizeof (data_ptr), 1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_OCTET_LENGTH_PTR,
(void *) string_length_ptr, sizeof (string_length_ptr),
1);
odbc_set_desc_field (desc, rec_number, SQL_DESC_INDICATOR_PTR,
(void *) indicator_ptr, sizeof (indicator_ptr), 1);
return ODBC_SUCCESS;
}
/************************************************************************
* 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_get_desc_rec
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
PUBLIC RETCODE
odbc_get_desc_rec (ODBC_DESC * desc,
SQLSMALLINT rec_number,
SQLCHAR *name,
SQLSMALLINT buffer_length,
SQLSMALLINT *string_length_ptr,
SQLSMALLINT *type_ptr,
SQLSMALLINT *subtype_ptr,
SQLLEN *length_ptr,
SQLSMALLINT *precision_ptr,
SQLSMALLINT *scale_ptr, SQLSMALLINT *nullable_ptr)
{
ODBC_RECORD *record = NULL;
SQLLEN tmp_length;
record = find_record_from_desc (desc, rec_number);
if (record == NULL)
{
odbc_set_diag (desc->diag, "07009", 0, NULL);
return ODBC_NO_DATA;
}
/* WARN : type converting string_length_ptr(short*) -> (long*) */
odbc_get_desc_field (desc, rec_number, SQL_DESC_NAME,
(void *) name, buffer_length,
&tmp_length);
*string_length_ptr = (SQLSMALLINT) tmp_length;
odbc_get_desc_field (desc, rec_number, SQL_DESC_TYPE,
(void *) type_ptr, 0, NULL);
odbc_get_desc_field (desc, rec_number, SQL_DESC_DATETIME_INTERVAL_CODE,
(void *) subtype_ptr, 0, NULL);
odbc_get_desc_field (desc, rec_number, SQL_DESC_OCTET_LENGTH,
(void *) length_ptr, 0, NULL);
odbc_get_desc_field (desc, rec_number, SQL_DESC_PRECISION,
(void *) precision_ptr, 0, NULL);
odbc_get_desc_field (desc, rec_number, SQL_DESC_SCALE,
(void *) scale_ptr, 0, NULL);
odbc_get_desc_field (desc, rec_number, SQL_DESC_NULLABLE,
(void *) nullable_ptr, 0, NULL);
return ODBC_SUCCESS;
}
/************************************************************************
* 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;
}
PUBLIC RETCODE
odbc_free_env (ODBC_ENV * env)
{
ODBC_ENV *e, *prev;
if (env->conn != NULL)
{
/* HY010 - DM */
odbc_set_diag (env->diag, "HY010", 0, NULL);
return ODBC_ERROR;
}
/* remove from list */
for (e = odbc_environments, prev = NULL; e != NULL && e != env; e = e->next)
{
prev = e;
}
if (e == env)
{
if (prev != NULL)
{
prev->next = env->next;
}
else
{
odbc_environments = env->next;
}
}
odbc_free_diag (env->diag, FREE_ALL);
env->diag = NULL;
NC_FREE (env->program_name);
UT_FREE (env);
return ODBC_SUCCESS;
}
/************************************************************************
* name: odbc_set_desc_field
* arguments:
* returns/side-effects:
* description:
* NOTE:
* CHECK : consistency
* 일부 consistency check가 odbc_set_desc_rec에서 이루어진다. 참고..
************************************************************************/
PUBLIC RETCODE
odbc_set_desc_field (ODBC_DESC * desc,
short rec_number,
short field_id,
void *value_ptr, long buffer_length, short is_driver)
{
ODBC_RECORD *record;
RETCODE status = ODBC_SUCCESS;
int i;
if (is_driver != 1 && is_read_only_field (field_id) == _TRUE_)
{
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
if (is_header_field (field_id) == 1)
{
/* header field */
switch (field_id)
{
case SQL_DESC_ALLOC_TYPE:
desc->alloc_type = (short) value_ptr;
break;
case SQL_DESC_ARRAY_SIZE:
desc->array_size = (unsigned long) value_ptr;
break;
case SQL_DESC_ARRAY_STATUS_PTR:
desc->array_status_ptr = value_ptr;
break;
case SQL_DESC_BIND_OFFSET_PTR:
desc->bind_offset_ptr = value_ptr;
break;
case SQL_DESC_BIND_TYPE:
desc->bind_type = (long) value_ptr;
break;
case SQL_DESC_COUNT:
if ((short) value_ptr < desc->max_count)
{
for (i = desc->max_count; i > (short) value_ptr && i > 0; --i)
{
record = find_record_from_desc (desc, i);
if (record != NULL)
{
odbc_free_record (record);
}
}
}
desc->max_count = (short) value_ptr;
break;
case SQL_DESC_ROWS_PROCESSED_PTR:
desc->rows_processed_ptr = value_ptr;
break;
default:
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
}
else
{
/* record filed */
if (rec_number < 0)
{
odbc_set_diag (desc->diag, "07009", 0, NULL);
goto error;
}
record = find_record_from_desc (desc, rec_number);
if (record == NULL)
{
odbc_alloc_record (desc, &record, rec_number);
}
switch (field_id)
{
case SQL_DESC_BASE_COLUMN_NAME:
case SQL_DESC_LABEL:
case SQL_DESC_NAME:
NC_FREE (record->name);
record->name = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_CASE_SENSITIVE:
record->case_sensitive = (long) value_ptr;
break;
case SQL_DESC_DISPLAY_SIZE:
record->display_size = (long) value_ptr;
break;
case SQL_DESC_FIXED_PREC_SCALE:
record->fixed_prec_scale = (short) value_ptr;
break;
case SQL_DESC_LITERAL_PREFIX:
NC_FREE (record->literal_prefix);
record->literal_prefix = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_LITERAL_SUFFIX:
NC_FREE (record->literal_suffix);
record->literal_suffix = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_LOCAL_TYPE_NAME:
NC_FREE (record->local_type_name);
record->local_type_name = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_NULLABLE:
record->nullable = (short) value_ptr;
break;
case SQL_DESC_SEARCHABLE:
record->searchable = (short) value_ptr;
break;
/* BASE_TABLE_NAME과 TABLE_NAME과의 구분은 없다. */
case SQL_DESC_TABLE_NAME:
case SQL_DESC_BASE_TABLE_NAME:
NC_FREE (record->table_name);
record->table_name = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_TYPE_NAME:
NC_FREE (record->type_name);
record->type_name = UT_MAKE_STRING (value_ptr, buffer_length);
break;
case SQL_DESC_UNSIGNED:
record->unsigned_type = (short) value_ptr;
break;
case SQL_DESC_CONCISE_TYPE:
if (!odbc_is_valid_type ((short) value_ptr))
{
odbc_set_diag (desc->diag, "HY021", 0, NULL);
goto error;
}
record->concise_type = (short) value_ptr;
break;
case SQL_DESC_DATA_PTR:
if (!odbc_consistency_check (record))
{
odbc_set_diag (desc->diag, "HY021", 0, NULL);
goto error;
}
record->data_ptr = value_ptr;
break;
case SQL_DESC_DATETIME_INTERVAL_CODE:
if (!odbc_is_valid_code ((short) value_ptr))
{
odbc_set_diag (desc->diag, "HY021", 0, NULL);
goto error;
}
record->datetime_interval_code = (short) value_ptr;
break;
case SQL_DESC_DATETIME_INTERVAL_PRECISION:
record->datetime_interval_precision = (short) value_ptr;
break;
case SQL_DESC_INDICATOR_PTR:
record->indicator_ptr = value_ptr;
break;
case SQL_DESC_LENGTH:
record->length = (unsigned long) value_ptr;
break;
case SQL_DESC_NUM_PREC_RADIX:
record->num_prec_radix = (long) value_ptr;
break;
case SQL_DESC_OCTET_LENGTH:
record->octet_length = (long) value_ptr;
break;
case SQL_DESC_OCTET_LENGTH_PTR:
record->octet_length_ptr = value_ptr;
break;
case SQL_DESC_PARAMETER_TYPE:
if ((short) value_ptr == SQL_PARAM_INPUT)
{
record->parameter_type = (short) value_ptr;
}
else
{
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
break;
case SQL_DESC_PRECISION:
record->precision = (short) value_ptr;
break;
case SQL_DESC_SCALE:
record->scale = (short) value_ptr;
break;
case SQL_DESC_TYPE:
switch ((short) value_ptr)
{
case SQL_CHAR: /* SQL_C_CHAR */
case SQL_VARCHAR:
record->type = (short) value_ptr;
record->length = 1;
record->precision = 0;
break;
case SQL_DATETIME:
record->type = (short) value_ptr;
switch (record->datetime_interval_code)
{
case SQL_CODE_DATE:
case SQL_CODE_TIME:
record->precision = 0;
break;
case SQL_CODE_TIMESTAMP:
record->precision = 6;
break;
}
break;
case SQL_DECIMAL:
case SQL_NUMERIC: /* SQL_C_NUMERIC */
record->type = (short) value_ptr;
record->precision = CUBRID_NUMERIC_PRECISION_DEFAULT;
record->scale = CUBRID_NUMERIC_SCALE_DEFAULT;
break;
case SQL_FLOAT:
case SQL_C_FLOAT:
record->type = (short) value_ptr;
/* WARN : NEED precision setting as default value */
break;
case SQL_INTERVAL:
odbc_set_diag (desc->diag, "HYC00", 0, NULL);
goto error;
case SQL_C_UBIGINT:
case SQL_C_SBIGINT:
case SQL_C_STINYINT:
case SQL_C_UTINYINT:
case SQL_C_TINYINT: // for 2.x backward compatibility
case SQL_C_SHORT: // for 2.x backward compatibility
case SQL_C_SSHORT:
case SQL_C_USHORT:
case SQL_C_LONG:
case SQL_C_SLONG:
case SQL_C_ULONG:
case SQL_C_GUID:
case SQL_BIT:
case SQL_BIGINT:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_LONGVARCHAR:
case SQL_C_DOUBLE:
case SQL_C_DEFAULT:
case SQL_TYPE_TIME:
case SQL_TYPE_TIMESTAMP:
case SQL_C_UNI_OBJECT:
case SQL_C_UNI_SET:
record->type = (short) value_ptr;
break;
default:
odbc_set_diag (desc->diag, "HY024", 0, NULL);
goto error;
}
break;
case SQL_DESC_UNNAMED:
switch ((short) value_ptr)
{
case SQL_NAMED:
case SQL_UNNAMED:
record->unnamed = (short) value_ptr;
break;
default:
odbc_set_diag (desc->diag, "HY024", 0, NULL);
goto error;
}
break;
case SQL_DESC_UPDATABLE:
record->updatable = (short) value_ptr;
break;
case SQL_DESC_AUTO_UNIQUE_VALUE:
case SQL_DESC_CATALOG_NAME:
case SQL_DESC_ROWVER:
case SQL_DESC_SCHEMA_NAME:
odbc_set_diag (desc->diag, "HYC00", 0, NULL);
goto error;
default:
/* unknown field */
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
}
return status;
error:
return ODBC_ERROR;
}
/************************************************************************
* name: odbc_get_desc_field
* arguments:
* returns/side-effects:
* description:
* NOTE:
* BASE_COLUMN_NAME, NAME, LABEL are same as SQL_DESC_NAME
************************************************************************/
PUBLIC RETCODE
odbc_get_desc_field (ODBC_DESC * desc,
SQLSMALLINT rec_number,
SQLSMALLINT field_id,
SQLPOINTER value_ptr,
SQLLEN buffer_length, SQLLEN *string_length_ptr)
{
RETCODE status = ODBC_SUCCESS, rc;
ODBC_RECORD *record;
char *pt;
char empty_str[1] = "";
if (is_header_field (field_id) == 1)
{
/* header field */
switch (field_id)
{
case SQL_DESC_COUNT:
if (value_ptr != NULL)
*(short *) value_ptr = desc->max_count;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->max_count);
break;
case SQL_DESC_ALLOC_TYPE:
if (value_ptr != NULL)
*(short *) value_ptr = desc->alloc_type;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->alloc_type);
break;
case SQL_DESC_ARRAY_SIZE:
if (value_ptr != NULL)
*(unsigned long *) value_ptr = desc->array_size;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->array_status_ptr);
break;
case SQL_DESC_ARRAY_STATUS_PTR:
if (value_ptr != NULL)
*(unsigned short **) value_ptr = desc->array_status_ptr;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->array_status_ptr);
break;
case SQL_DESC_BIND_OFFSET_PTR:
if (value_ptr != NULL)
*(long **) value_ptr = desc->bind_offset_ptr;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->bind_offset_ptr);
break;
case SQL_DESC_BIND_TYPE:
if (value_ptr != NULL)
*(long *) value_ptr = desc->bind_type;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->bind_type);
break;
case SQL_DESC_ROWS_PROCESSED_PTR:
if (value_ptr != NULL)
*(unsigned long **) value_ptr = desc->rows_processed_ptr;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (desc->rows_processed_ptr);
break;
default:
/* unknown field */
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
}
else
{
/* record filed */
if (rec_number < 0)
{
odbc_set_diag (desc->diag, "07009", 0, NULL);
goto error;
}
record = find_record_from_desc (desc, rec_number);
if (record == NULL)
{
odbc_set_diag (desc->diag, "07009", 0, NULL);
goto error;
}
switch (field_id)
{
case SQL_DESC_BASE_COLUMN_NAME:
case SQL_DESC_LABEL:
case SQL_DESC_NAME:
if (record->name != NULL)
{
pt = record->name;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_CASE_SENSITIVE:
if (value_ptr != NULL)
*(long *) value_ptr = record->case_sensitive;
if (string_length_ptr != NULL)
*string_length_ptr = sizeof (record->case_sensitive);
break;
case SQL_DESC_CONCISE_TYPE:
if (value_ptr != NULL)
*(short *) value_ptr = record->concise_type;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->concise_type);
}
break;
case SQL_DESC_DATA_PTR:
if (value_ptr != NULL)
*(void **) value_ptr = record->data_ptr;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->data_ptr);
}
break;
case SQL_DESC_DATETIME_INTERVAL_CODE:
if (value_ptr != NULL)
*(short *) value_ptr = record->datetime_interval_code;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->datetime_interval_code);
}
break;
case SQL_DESC_DATETIME_INTERVAL_PRECISION:
if (value_ptr != NULL)
*(long *) value_ptr = record->datetime_interval_precision;
if (string_length_ptr != NULL)
{
*string_length_ptr =
sizeof (record->datetime_interval_precision);
}
break;
case SQL_DESC_DISPLAY_SIZE:
if (value_ptr != NULL)
*(long *) value_ptr = record->display_size;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->display_size);
}
break;
case SQL_DESC_FIXED_PREC_SCALE:
if (value_ptr != NULL)
*(short *) value_ptr = record->fixed_prec_scale;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->fixed_prec_scale);
}
break;
case SQL_DESC_INDICATOR_PTR:
if (value_ptr != NULL)
*(long **) value_ptr = record->indicator_ptr;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->indicator_ptr);
}
break;
case SQL_DESC_LENGTH:
case SQL_COLUMN_LENGTH: // for 2.x backward compatibility
if (value_ptr != NULL)
*(unsigned long *) value_ptr = record->length;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->length);
}
break;
case SQL_DESC_LITERAL_PREFIX:
if (record->literal_prefix != NULL)
{
pt = record->literal_prefix;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_LITERAL_SUFFIX:
if (record->literal_suffix != NULL)
{
pt = record->literal_suffix;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_LOCAL_TYPE_NAME:
if (record->local_type_name != NULL)
{
pt = record->local_type_name;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_NULLABLE:
if (value_ptr != NULL)
*(short *) value_ptr = record->nullable;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->nullable);
}
break;
case SQL_DESC_NUM_PREC_RADIX:
if (value_ptr != NULL)
*(long *) value_ptr = record->num_prec_radix;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->num_prec_radix);
}
break;
case SQL_DESC_OCTET_LENGTH:
if (value_ptr != NULL)
*(long *) value_ptr = record->octet_length;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->octet_length);
}
break;
case SQL_DESC_OCTET_LENGTH_PTR:
if (value_ptr != NULL)
*(long **) value_ptr = record->octet_length_ptr;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->octet_length_ptr);
}
break;
case SQL_DESC_PARAMETER_TYPE:
if (value_ptr != NULL)
*(short *) value_ptr = record->parameter_type;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->parameter_type);
}
break;
case SQL_DESC_PRECISION:
case SQL_COLUMN_PRECISION: // for 2.x backward compatibility
if (value_ptr != NULL)
*(short *) value_ptr = record->precision;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->precision);
}
break;
case SQL_DESC_SCALE:
case SQL_COLUMN_SCALE: // for 2.x backward compatibility
if (value_ptr != NULL)
*(short *) value_ptr = record->scale;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->scale);
}
break;
case SQL_DESC_SEARCHABLE:
if (value_ptr != NULL)
*(short *) value_ptr = record->searchable;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->searchable);
}
break;
case SQL_DESC_TABLE_NAME:
case SQL_DESC_BASE_TABLE_NAME: /* 따로 지원하지 않고 TABLE_NAME과 같이 쓴다. */
if (record->table_name != NULL)
{
pt = record->table_name;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_TYPE:
if (value_ptr != NULL)
*(short *) value_ptr = record->type;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->type);
}
break;
case SQL_DESC_TYPE_NAME:
if (record->type_name != NULL)
{
pt = record->type_name;
}
else
{
pt = empty_str;
}
rc =
str_value_assign (pt, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_UNNAMED:
if (value_ptr != NULL)
*(short *) value_ptr = record->unnamed;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->unnamed);
}
break;
case SQL_DESC_UNSIGNED:
if (value_ptr != NULL)
*(short *) value_ptr = record->unsigned_type;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (record->unsigned_type);
}
break;
case SQL_DESC_AUTO_UNIQUE_VALUE:
// there is no auto unique attribute in CUBRID
if (value_ptr != NULL)
*(long *) value_ptr = SQL_FALSE;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (long);
}
break;
case SQL_DESC_CATALOG_NAME:
case SQL_DESC_SCHEMA_NAME:
// empty string
rc =
str_value_assign (empty_str, value_ptr, buffer_length,
string_length_ptr);
if (rc == ODBC_SUCCESS_WITH_INFO)
{
odbc_set_diag (desc->diag, "01004", 0, NULL);
}
break;
case SQL_DESC_ROWVER:
// there is no rowver attribute in CUBRID
if (value_ptr != NULL)
*(short *) value_ptr = SQL_FALSE;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (short);
}
break;
case SQL_DESC_UPDATABLE:
// always READWRITE_UNKNOWN
if (value_ptr != NULL)
*(short *) value_ptr = SQL_ATTR_READWRITE_UNKNOWN;
if (string_length_ptr != NULL)
{
*string_length_ptr = sizeof (short);
}
break;
default:
odbc_set_diag (desc->diag, "HY091", 0, NULL);
goto error;
}
}
return status;
error:
return ODBC_ERROR;
}
/************************************************************************
* name: odbc_set_env_attr
* arguments:
* ODBC_ENV *env - environment handle
* attribute - attribute type
* valueptr - generic value pointer
* stringlength - SQL_IS_INTEGER(-6) or string length
* returns/side-effects:
* RETCODE
* description:
*
* NOTE:
* diagnostic에 대해서 아직 structure가 설정이 되지 않아서 SQLSTATE를
* 설정하지 못한다. structure에 반영한 후 각 state 값을 설정하도록
* 한다.
************************************************************************/
PUBLIC RETCODE
odbc_set_env_attr (ODBC_ENV * env,
long attribute, void *valueptr, long stringlength)
{
if (valueptr == NULL)
{
odbc_set_diag (env->diag, "HY009", 0, NULL);
return ODBC_ERROR;
}
/* valueptr will be a 32-bit integer value or
* point to a null-terminated character string
*/
switch (attribute)
{
case SQL_ATTR_CONNECTION_POOLING:
odbc_set_diag (env->diag, "HYC00", 0, NULL);
return ODBC_ERROR;
break;
case SQL_ATTR_CP_MATCH:
odbc_set_diag (env->diag, "HYC00", 0, NULL);
return ODBC_ERROR;
break;
case SQL_ATTR_ODBC_VERSION:
switch ((long) valueptr)
{
case SQL_OV_ODBC3:
case SQL_OV_ODBC2:
env->attr_odbc_version = (long) valueptr;
break;
default:
odbc_set_diag (env->diag, "HY024", 0, NULL);
return ODBC_ERROR;
break;
}
break;
case SQL_ATTR_OUTPUT_NTS:
switch ((long) valueptr)
{
case SQL_TRUE:
env->attr_output_nts = (unsigned long) valueptr;
break;
case SQL_FALSE:
odbc_set_diag (env->diag, "HYC00", 0, NULL);
return ODBC_ERROR;
break;
default:
odbc_set_diag (env->diag, "HY024", 0, NULL);
return ODBC_ERROR;
break;
}
break;
default:
odbc_set_diag (env->diag, "HY092", 0, NULL);
return ODBC_ERROR;
break;
}
return ODBC_SUCCESS;
}
