DBD-cubrid
view release on metacpan or search on metacpan
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
do { \
PTR = MALLOC(sizeof(double)); \
if (PTR != NULL) { \
*((double*) (PTR)) = VALUE; \
} \
} while (0)
#define ALLOC_COPY_DATE(PTR, VALUE) \
do { \
PTR = MALLOC(sizeof(T_CCI_DATE)); \
if (PTR != NULL) { \
*((T_CCI_DATE*) (PTR)) = VALUE; \
} \
} while (0)
#define ALLOC_COPY_DATE_TZ(PTR, VALUE) \
do { \
PTR = MALLOC(sizeof(T_CCI_DATE_TZ)); \
if (PTR != NULL) { \
*((T_CCI_DATE_TZ*) (PTR)) = VALUE; \
} \
} while (0)
#define ALLOC_COPY_OBJECT(PTR, VALUE) \
do { \
PTR = MALLOC(sizeof(T_OBJECT)); \
if (PTR != NULL) { \
*((T_OBJECT*) (PTR)) = VALUE; \
} \
} while (0)
#define ALLOC_COPY_BIT(DEST, SRC, SIZE) \
do { \
DEST = MALLOC(SIZE); \
if (DEST != NULL) { \
memcpy(DEST, SRC, SIZE); \
} \
} while (0)
#define EXECUTE_ARRAY 0
#define EXECUTE_BATCH 1
#define EXECUTE_EXEC 2
/************************************************************************
* PRIVATE TYPE DEFINITIONS *
************************************************************************/
typedef enum
{
FETCH_FETCH,
FETCH_OID_GET,
FETCH_COL_GET
} T_FETCH_TYPE;
/************************************************************************
* PRIVATE FUNCTION PROTOTYPES *
************************************************************************/
static int prepare_info_decode (char *buf, int *size, T_REQ_HANDLE * req_handle);
static int out_rs_info_decode (char *buf, int *size, T_REQ_HANDLE * req_handle);
static int get_cursor_pos (T_REQ_HANDLE * req_handle, int offset, char origin);
static int fetch_info_decode (char *buf, int size, int num_cols, T_TUPLE_VALUE ** tuple_value, T_FETCH_TYPE fetch_type,
T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle);
static void stream_to_obj (char *buf, T_OBJECT * obj);
static int get_data_set (T_CCI_U_EXT_TYPE u_ext_type, char *col_value_p, T_SET ** value, int data_size);
#if defined (ENABLE_UNUSED_FUNCTION)
static int get_file_size (char *filename);
#endif
static int get_column_info (char *buf_p, int *remain_size, T_CCI_COL_INFO ** ret_col_info, char **next_buf_p,
bool is_prepare);
static int oid_get_info_decode (char *buf_p, int remain_size, T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle);
static int schema_info_decode (char *buf_p, int size, T_REQ_HANDLE * req_handle);
static int col_get_info_decode (char *buf_p, int remain_size, int *col_size, int *col_type, T_REQ_HANDLE * req_handle,
T_CON_HANDLE * con_handle);
static int next_result_info_decode (char *buf, int size, T_REQ_HANDLE * req_handle);
static int bind_value_conversion (T_CCI_A_TYPE a_type, T_CCI_U_TYPE u_type, char flag, void *value, int length,
T_BIND_VALUE * bind_value);
static int bind_value_to_net_buf (T_NET_BUF * net_buf, T_CCI_U_TYPE u_type, void *value, int size, char *charset,
bool set_default_value);
static int execute_array_info_decode (char *buf, int size, char flag, T_CCI_QUERY_RESULT ** qr, int *res_remain_size);
static T_CCI_U_TYPE get_basic_utype (T_CCI_U_EXT_TYPE u_ext_type);
static int parameter_info_decode (char *buf, int size, int num_param, T_CCI_PARAM_INFO ** res_param);
static int decode_fetch_result (T_CON_HANDLE * con_handle, T_REQ_HANDLE * req_handle, char *result_msg_org,
char *result_msg_start, int result_msg_size);
static int qe_close_req_handle_internal (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, bool force_close);
static int qe_send_close_handle_msg (T_CON_HANDLE * con_handle, int server_handle_id);
#if defined(WINDOWS)
static int get_windows_charset_code (char *str);
#endif
#ifdef CCI_XA
static void add_arg_xid (T_NET_BUF * net_buf, XID * xid);
static int xa_prepare_info_decode (char *buf, int buf_size, int count, XID * xid, int num_xid_buf);
static void net_str_to_xid (char *buf, XID * xid);
#endif
static int shard_info_decode (char *buf_p, int size, int num_shard, T_CCI_SHARD_INFO ** shard_info);
static bool is_set_default_value_if_null (T_CON_HANDLE * con_handle, T_CCI_CUBRID_STMT stmt_type, char bind_mode);
static T_CCI_U_EXT_TYPE get_ext_utype_from_net_bytes (T_CCI_U_TYPE basic_type, T_CCI_U_TYPE set_type);
static void confirm_schema_type_info (T_REQ_HANDLE * req_handle, int col_no, T_CCI_U_TYPE u_type, char *col_value_p,
int data_size);
/************************************************************************
* INTERFACE VARIABLES *
************************************************************************/
/************************************************************************
* PUBLIC VARIABLES *
************************************************************************/
/************************************************************************
* PRIVATE VARIABLES *
************************************************************************/
/************************************************************************
* IMPLEMENTATION OF INTERFACE FUNCTIONS *
************************************************************************/
/************************************************************************
* IMPLEMENTATION OF PUBLIC FUNCTIONS *
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
ADD_ARG_BYTES (&net_buf, &flag, 1);
autocommit_flag = (char) con_handle->autocommit_mode;
ADD_ARG_BYTES (&net_buf, &autocommit_flag, 1);
while (con_handle->deferred_close_handle_count > 0)
{
ADD_ARG_INT (&net_buf, con_handle->deferred_close_handle_list[--con_handle->deferred_close_handle_count]);
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
if (TIMEOUT_IS_SET (con_handle))
{
remaining_time = con_handle->current_timeout;
remaining_time -= get_elapsed_time (&con_handle->start_time);
if (remaining_time <= 0)
{
net_buf_clear (&net_buf);
return CCI_ER_QUERY_TIMEOUT;
}
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
{
return err_code;
}
result_code = net_recv_msg_timeout (con_handle, &result_msg, &result_msg_size, err_buf, remaining_time);
if (result_code < 0)
{
return result_code;
}
result_msg_size -= 4;
err_code = prepare_info_decode (result_msg + 4, &result_msg_size, req_handle);
if (err_code < 0)
{
FREE_MEM (result_msg);
return err_code;
}
FREE_MEM (result_msg);
req_handle->handle_type = HANDLE_PREPARE;
req_handle->handle_sub_type = 0;
req_handle->server_handle_id = result_code;
req_handle->cur_fetch_tuple_index = -1;
if ((flag & CCI_PREPARE_UPDATABLE) != 0)
{
flag |= CCI_PREPARE_INCLUDE_OID;
}
req_handle->prepare_flag = flag;
req_handle->cursor_pos = 0;
req_handle->is_closed = 0;
req_handle->valid = 1;
req_handle->is_from_current_transaction = 1;
if (!reuse)
{
if (req_handle->num_bind > 0)
{
req_handle->bind_value = (T_BIND_VALUE *) MALLOC (sizeof (T_BIND_VALUE) * req_handle->num_bind);
if (req_handle->bind_value == NULL)
{
return CCI_ER_NO_MORE_MEMORY;
}
memset (req_handle->bind_value, 0, sizeof (T_BIND_VALUE) * req_handle->num_bind);
req_handle->bind_mode = (char *) MALLOC (req_handle->num_bind);
if (req_handle->bind_mode == NULL)
{
return CCI_ER_NO_MORE_MEMORY;
}
memset (req_handle->bind_mode, CCI_PARAM_MODE_UNKNOWN, req_handle->num_bind);
}
}
return CCI_ER_NO_ERROR;
}
int
qe_bind_param (T_REQ_HANDLE * req_handle, int index, T_CCI_A_TYPE a_type, void *value, int length, T_CCI_U_TYPE u_type,
char flag)
{
int err_code;
assert (u_type >= CCI_U_TYPE_FIRST && u_type <= CCI_U_TYPE_LAST);
index--;
if (index < 0 || index >= req_handle->num_bind)
{
return CCI_ER_BIND_INDEX;
}
if (req_handle->bind_value[index].flag == BIND_PTR_DYNAMIC)
{
FREE_MEM (req_handle->bind_value[index].value);
memset (&(req_handle->bind_value[index]), 0, sizeof (T_BIND_VALUE));
}
req_handle->bind_mode[index] = CCI_PARAM_MODE_IN;
if (value == NULL || u_type == CCI_U_TYPE_NULL)
{
req_handle->bind_value[index].u_type = CCI_U_TYPE_NULL;
return 0;
}
err_code = bind_value_conversion (a_type, u_type, flag, value, length, &(req_handle->bind_value[index]));
return err_code;
}
int
qe_execute (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char flag, int max_col_size, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_EXECUTE;
char autocommit_flag;
int i;
int err_code = 0;
int res_count;
char *result_msg = NULL, *msg;
int result_msg_size;
T_CCI_QUERY_RESULT *qr = NULL;
char fetch_flag;
char forward_only_cursor;
char include_column_info;
int remain_msg_size = 0;
int remaining_time = 0;
bool use_server_query_cancel = false;
int shard_id;
T_BROKER_VERSION broker_ver;
req_handle->is_fetch_completed = 0;
QUERY_RESULT_FREE (req_handle);
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
ADD_ARG_BYTES (&net_buf, &flag, 1);
ADD_ARG_INT (&net_buf, max_col_size);
ADD_ARG_INT (&net_buf, req_handle->max_row);
if (req_handle->first_stmt_type == CUBRID_STMT_CALL_SP)
{
ADD_ARG_BYTES (&net_buf, req_handle->bind_mode, req_handle->num_bind);
}
else
{
ADD_ARG_BYTES (&net_buf, NULL, 0);
}
if (req_handle->first_stmt_type == CUBRID_STMT_SELECT)
{
fetch_flag = 1;
}
else
{
fetch_flag = 0;
}
ADD_ARG_BYTES (&net_buf, &fetch_flag, 1);
if (con_handle->autocommit_mode == CCI_AUTOCOMMIT_TRUE)
{
forward_only_cursor = true;
}
else
{
forward_only_cursor = false;
}
autocommit_flag = (char) con_handle->autocommit_mode;
ADD_ARG_BYTES (&net_buf, &autocommit_flag, 1);
ADD_ARG_BYTES (&net_buf, &forward_only_cursor, 1);
ADD_ARG_CACHE_TIME (&net_buf, 0, 0);
if (TIMEOUT_IS_SET (con_handle))
{
remaining_time = con_handle->current_timeout;
remaining_time -= get_elapsed_time (&con_handle->start_time);
if (remaining_time <= 0)
{
err_code = CCI_ER_QUERY_TIMEOUT;
goto execute_error;
}
}
broker_ver = hm_get_broker_version (con_handle);
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V2))
{
/* In PROTOCOL_V2, cci driver use server query timeout feature, when disconnect_on_query_timeout is false. */
if (TIMEOUT_IS_SET (con_handle) && con_handle->disconnect_on_query_timeout == false)
{
use_server_query_cancel = true;
}
ADD_ARG_INT (&net_buf, remaining_time);
}
else if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V1))
{
/* cci does not use server query timeout in PROTOCOL_V1 */
ADD_ARG_INT (&net_buf, 0);
}
for (i = 0; i < req_handle->num_bind; i++)
{
bind_value_to_net_buf (&net_buf, req_handle->bind_value[i].u_type, req_handle->bind_value[i].value,
req_handle->bind_value[i].size, con_handle->charset,
is_set_default_value_if_null (con_handle, req_handle->stmt_type,
req_handle->bind_mode[i]));
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
goto execute_error;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
if (err_code < 0)
{
goto execute_error;
}
net_buf_clear (&net_buf);
res_count =
net_recv_msg_timeout (con_handle, &result_msg, &result_msg_size, err_buf,
((use_server_query_cancel) ? 0 : remaining_time));
if (res_count < 0)
{
return res_count;
}
err_code = execute_array_info_decode (result_msg + 4, result_msg_size - 4, EXECUTE_EXEC, &qr, &remain_msg_size);
if (err_code < 0 || remain_msg_size < 0)
{
FREE_MEM (result_msg);
if (err_code == CCI_ER_NO_ERROR)
{
return CCI_ER_COMMUNICATION;
}
return err_code;
}
if (qr == NULL)
{
req_handle->num_query_res = 0;
req_handle->qr = NULL;
}
else
{
req_handle->num_query_res = err_code;
req_handle->qr = qr;
}
if (req_handle->first_stmt_type == CUBRID_STMT_SELECT || req_handle->first_stmt_type == CUBRID_STMT_GET_STATS
|| req_handle->first_stmt_type == CUBRID_STMT_CALL || req_handle->first_stmt_type == CUBRID_STMT_EVALUATE)
{
req_handle->num_tuple = res_count;
}
else if (req_handle->first_stmt_type == CUBRID_STMT_CALL_SP)
{
req_handle->num_tuple = res_count;
}
else
{
req_handle->num_tuple = -1;
}
req_handle->execute_flag = flag;
hm_req_handle_fetch_buf_free (req_handle);
req_handle->cursor_pos = 0;
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V2))
{
msg = result_msg + (result_msg_size - remain_msg_size);
NET_STR_TO_BYTE (include_column_info, msg);
remain_msg_size -= NET_SIZE_BYTE;
msg += NET_SIZE_BYTE;
if (include_column_info == 1)
{
err_code = prepare_info_decode (msg, &remain_msg_size, req_handle);
if (err_code < 0)
{
FREE_MEM (result_msg);
return err_code;
}
}
}
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V5))
{
msg = result_msg + (result_msg_size - remain_msg_size);
NET_STR_TO_INT (shard_id, msg);
remain_msg_size -= NET_SIZE_INT;
msg += NET_SIZE_INT;
con_handle->shard_id = shard_id;
req_handle->shard_id = shard_id;
}
/* If fetch_flag is 1, executing query and fetching data is processed together. So, fetching results are included in
* result_msg. */
if (req_handle->first_stmt_type == CUBRID_STMT_SELECT)
{
int num_tuple;
req_handle->cursor_pos = 1;
num_tuple =
decode_fetch_result (con_handle, req_handle, result_msg, result_msg + (result_msg_size - remain_msg_size) + 4,
remain_msg_size - 4);
req_handle->cursor_pos = 0;
if (num_tuple < 0)
{
FREE_MEM (result_msg);
return num_tuple;
}
}
else
{
FREE_MEM (result_msg);
}
req_handle->is_closed = 0;
req_handle->is_from_current_transaction = 1;
return res_count;
execute_error:
net_buf_clear (&net_buf);
return err_code;
}
int
qe_prepare_and_execute (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char *sql_stmt, int max_col_size,
T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_PREPARE_AND_EXECUTE;
char autocommit_flag;
int sql_stmt_size;
int err_code;
int result_code;
int execute_res_count;
char *result_msg = NULL;
char *msg;
char *result_msg_org;
int result_msg_size;
T_CCI_QUERY_RESULT *qr = NULL;
char fetch_flag;
char include_column_info;
int remain_msg_size = 0;
int remaining_time = 0;
int num_tuple = 0;
char prepare_flag = 0;
char execute_flag = CCI_EXEC_QUERY_ALL;
int prepare_argc_count = 3;
bool use_server_query_cancel = false;
int shard_id;
T_BROKER_VERSION broker_ver;
QUERY_RESULT_FREE (req_handle);
ALLOC_COPY (req_handle->sql_text, sql_stmt);
if (req_handle->sql_text == NULL)
{
return CCI_ER_NO_MORE_MEMORY;
}
sql_stmt_size = strlen (req_handle->sql_text) + 1;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
/* In PROTOCOL_V2, cci driver use server query timeout feature, when disconnect_on_query_timeout is false. */
if (TIMEOUT_IS_SET (con_handle) && con_handle->disconnect_on_query_timeout == false)
{
use_server_query_cancel = true;
}
ADD_ARG_INT (&net_buf, remaining_time);
}
else if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V1))
{
/* cci does not use server query timeout in PROTOCOL_V1 */
ADD_ARG_INT (&net_buf, 0);
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
goto prepare_and_execute_error;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
if (err_code < 0)
{
goto prepare_and_execute_error;
}
net_buf_clear (&net_buf);
/* prepare result */
result_code =
net_recv_msg_timeout (con_handle, &result_msg, &result_msg_size, err_buf,
((use_server_query_cancel) ? 0 : remaining_time));
if (result_code < 0)
{
return result_code;
}
result_msg_org = result_msg;
result_msg += 4;
result_msg_size -= 4;
remain_msg_size = result_msg_size;
err_code = prepare_info_decode (result_msg, &result_msg_size, req_handle);
if (err_code < 0)
{
FREE_MEM (result_msg_org);
return err_code;
}
req_handle->handle_type = HANDLE_PREPARE;
req_handle->handle_sub_type = 0;
req_handle->server_handle_id = result_code;
req_handle->cur_fetch_tuple_index = -1;
if ((prepare_flag & CCI_PREPARE_UPDATABLE) != 0)
{
prepare_flag |= CCI_PREPARE_INCLUDE_OID;
}
req_handle->prepare_flag = prepare_flag;
req_handle->cursor_pos = 0;
req_handle->is_closed = 0;
req_handle->valid = 1;
req_handle->is_from_current_transaction = 1;
if (req_handle->stmt_type == CUBRID_STMT_SELECT)
{
fetch_flag = 1;
}
else
{
fetch_flag = 0;
}
/* execute result */
result_msg += (remain_msg_size - result_msg_size);
memcpy ((char *) &execute_res_count, result_msg + CAS_PROTOCOL_ERR_INDICATOR_INDEX, CAS_PROTOCOL_ERR_INDICATOR_SIZE);
execute_res_count = ntohl (execute_res_count);
result_msg += 4;
result_msg_size -= 4;
err_code = execute_array_info_decode (result_msg, result_msg_size, EXECUTE_EXEC, &qr, &remain_msg_size);
if (err_code < 0 || remain_msg_size < 0)
{
FREE_MEM (result_msg_org);
if (err_code == CCI_ER_NO_ERROR)
{
return CCI_ER_COMMUNICATION;
}
return err_code;
}
if (qr == NULL)
{
req_handle->num_query_res = 0;
req_handle->qr = NULL;
}
else
{
req_handle->num_query_res = err_code;
req_handle->qr = qr;
}
if (req_handle->stmt_type == CUBRID_STMT_SELECT || req_handle->stmt_type == CUBRID_STMT_GET_STATS
|| req_handle->stmt_type == CUBRID_STMT_CALL || req_handle->stmt_type == CUBRID_STMT_EVALUATE)
{
req_handle->num_tuple = execute_res_count;
}
else if (req_handle->stmt_type == CUBRID_STMT_CALL_SP)
{
req_handle->num_tuple = execute_res_count;
}
else
{
req_handle->num_tuple = -1;
}
req_handle->execute_flag = execute_flag;
hm_req_handle_fetch_buf_free (req_handle);
req_handle->cursor_pos = 0;
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V2))
{
msg = result_msg + (result_msg_size - remain_msg_size);
NET_STR_TO_BYTE (include_column_info, msg);
remain_msg_size -= NET_SIZE_BYTE;
msg += NET_SIZE_BYTE;
if (include_column_info == 1)
{
err_code = prepare_info_decode (msg, &remain_msg_size, req_handle);
if (err_code < 0)
{
FREE_MEM (result_msg_org);
return err_code;
}
}
}
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V5))
{
msg = result_msg + (result_msg_size - remain_msg_size);
NET_STR_TO_INT (shard_id, msg);
remain_msg_size -= NET_SIZE_INT;
msg += NET_SIZE_INT;
con_handle->shard_id = shard_id;
req_handle->shard_id = shard_id;
}
/* If fetch_flag is 1, executing query and fetching data is processed together. So, fetching results are included in
* result_msg. */
if (fetch_flag)
{
req_handle->cursor_pos = 1;
num_tuple =
decode_fetch_result (con_handle, req_handle, result_msg_org,
result_msg + (result_msg_size - remain_msg_size) + 4, remain_msg_size - 4);
req_handle->cursor_pos = 0;
if (num_tuple < 0)
{
FREE_MEM (result_msg_org);
return num_tuple;
}
}
else
{
FREE_MEM (result_msg_org);
}
return execute_res_count;
prepare_and_execute_error:
net_buf_clear (&net_buf);
return err_code;
}
void
qe_bind_value_free (T_REQ_HANDLE * req_handle)
{
int i;
if (req_handle->bind_value == NULL)
{
return;
}
for (i = 0; i < req_handle->num_bind; i++)
{
if (req_handle->bind_value[i].flag == BIND_PTR_DYNAMIC)
{
FREE_MEM (req_handle->bind_value[i].value);
req_handle->bind_value[i].flag = BIND_PTR_STATIC;
}
}
}
int
qe_get_db_parameter (T_CON_HANDLE * con_handle, T_CCI_DB_PARAM param_name, void *ret_val, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_GET_DB_PARAMETER;
char *result_msg = NULL;
int result_msg_size;
int err_code = CCI_ER_NO_ERROR;
int val;
T_BROKER_VERSION broker_ver;
if (ret_val == NULL)
{
return CCI_ER_NO_ERROR;
}
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, param_name);
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
return err_code;
}
void
qe_close_req_handle_all (T_CON_HANDLE * con_handle)
{
int i;
T_REQ_HANDLE *req_handle;
/* close handle in req handle table */
for (i = 0; i < con_handle->max_req_handle; i++)
{
if (con_handle->req_handle_table[i] == NULL)
{
continue;
}
req_handle = con_handle->req_handle_table[i];
map_close_ots (req_handle->mapped_stmt_id);
req_handle->mapped_stmt_id = -1;
qe_close_req_handle_internal (req_handle, con_handle, false);
}
hm_req_handle_free_all (con_handle);
}
static int
qe_send_close_handle_msg (T_CON_HANDLE * con_handle, int server_handle_id)
{
int err_code = 0;
T_NET_BUF net_buf;
char func_code = CAS_FC_CLOSE_REQ_HANDLE;
char autocommit_flag;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, server_handle_id);
autocommit_flag = (char) con_handle->autocommit_mode;
ADD_ARG_BYTES (&net_buf, &autocommit_flag, 1);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
{
return err_code;
}
err_code = net_recv_msg (con_handle, NULL, NULL, NULL);
return err_code;
}
int
qe_cursor (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, int offset, char origin, T_CCI_ERROR * err_buf)
{
char func_code = CAS_FC_CURSOR;
int err_code;
char *result_msg = NULL;
int result_msg_size;
T_NET_BUF net_buf;
char *cur_p;
int tuple_num;
int cursor_pos;
if (req_handle->is_closed)
{
return CCI_ER_RESULT_SET_CLOSED;
}
if (req_handle->handle_type == HANDLE_PREPARE)
{
if (req_handle->stmt_type == CUBRID_STMT_SELECT || req_handle->stmt_type == CUBRID_STMT_GET_STATS
|| req_handle->stmt_type == CUBRID_STMT_CALL || req_handle->stmt_type == CUBRID_STMT_CALL_SP
|| req_handle->stmt_type == CUBRID_STMT_EVALUATE)
{
if (req_handle->num_tuple >= 0)
{
cursor_pos = get_cursor_pos (req_handle, offset, origin);
if (cursor_pos <= 0)
{
req_handle->cursor_pos = 0;
return CCI_ER_NO_MORE_DATA;
}
else if (cursor_pos > req_handle->num_tuple)
{
req_handle->cursor_pos = req_handle->num_tuple + 1;
return CCI_ER_NO_MORE_DATA;
}
if (is_connected_to_oracle (con_handle) && cursor_pos > req_handle->fetched_tuple_end
&& req_handle->is_fetch_completed)
{
return CCI_ER_NO_MORE_DATA;
}
req_handle->cursor_pos = cursor_pos;
return 0;
}
else
{ /* async query */
if (origin != CCI_CURSOR_LAST)
{
cursor_pos = get_cursor_pos (req_handle, offset, origin);
req_handle->cursor_pos = cursor_pos;
if (req_handle->fetched_tuple_begin > 0 && cursor_pos >= req_handle->fetched_tuple_begin
&& cursor_pos <= req_handle->fetched_tuple_end)
{
return 0;
}
if (cursor_pos <= 0)
{
req_handle->cursor_pos = 0;
return CCI_ER_NO_MORE_DATA;
}
}
}
}
else
{
return CCI_ER_NO_MORE_DATA;
}
}
else if (req_handle->handle_type == HANDLE_SCHEMA_INFO || req_handle->handle_type == HANDLE_COL_GET)
{
cursor_pos = get_cursor_pos (req_handle, offset, origin);
if (cursor_pos <= 0 || cursor_pos > req_handle->num_tuple)
{
if (cursor_pos <= 0)
req_handle->cursor_pos = 0;
else if (cursor_pos > req_handle->num_tuple)
req_handle->cursor_pos = req_handle->num_tuple + 1;
return CCI_ER_NO_MORE_DATA;
}
req_handle->cursor_pos = cursor_pos;
return 0;
}
else if (req_handle->handle_type == HANDLE_OID_GET)
return 0;
if (origin == CCI_CURSOR_FIRST || origin == CCI_CURSOR_LAST)
{
cursor_pos = offset;
}
else if (origin == CCI_CURSOR_CURRENT)
{
cursor_pos = req_handle->cursor_pos;
origin = CCI_CURSOR_FIRST;
}
else
return CCI_ER_INVALID_CURSOR_POS;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
ADD_ARG_INT (&net_buf, cursor_pos);
ADD_ARG_BYTES (&net_buf, &origin, 1);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
goto cursor_error;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
if (err_code < 0)
{
goto cursor_error;
}
net_buf_clear (&net_buf);
err_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (err_code < 0)
{
return err_code;
}
if (result_msg == NULL)
{
return CCI_ER_COMMUNICATION;
}
cur_p = result_msg + NET_SIZE_INT;
result_msg_size -= NET_SIZE_INT;
if (result_msg_size < NET_SIZE_INT)
{
FREE_MEM (result_msg);
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (tuple_num, cur_p);
req_handle->num_tuple = tuple_num;
FREE_MEM (result_msg);
if (origin == CCI_CURSOR_FIRST)
{
if (req_handle->num_tuple >= 0 && req_handle->cursor_pos > req_handle->num_tuple)
{
req_handle->cursor_pos = req_handle->num_tuple + 1;
return CCI_ER_NO_MORE_DATA;
}
req_handle->cursor_pos = cursor_pos;
}
else
{
if (req_handle->num_tuple <= 0 || req_handle->num_tuple - cursor_pos + 1 <= 0)
{
req_handle->cursor_pos = 0;
return CCI_ER_NO_MORE_DATA;
}
req_handle->cursor_pos = req_handle->num_tuple - cursor_pos + 1;
}
return 0;
cursor_error:
net_buf_clear (&net_buf);
return err_code;
}
int
qe_fetch (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char flag, int result_set_index, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
int err_code;
char func_code = CAS_FC_FETCH;
char *result_msg = NULL;
int result_msg_size;
int num_tuple;
if (req_handle->cursor_pos <= 0)
{
return CCI_ER_NO_MORE_DATA;
}
if (req_handle->is_closed)
{
return CCI_ER_RESULT_SET_CLOSED;
}
if (req_handle->fetched_tuple_begin > 0 && req_handle->cursor_pos >= req_handle->fetched_tuple_begin
&& req_handle->cursor_pos <= req_handle->fetched_tuple_end)
{
req_handle->cur_fetch_tuple_index = req_handle->cursor_pos - req_handle->fetched_tuple_begin;
if (flag)
{
if (ut_is_deleted_oid (&(req_handle->tuple_value[req_handle->cur_fetch_tuple_index].tuple_oid)))
{
return CCI_ER_DELETED_TUPLE;
}
}
return 0;
}
hm_req_handle_fetch_buf_free (req_handle);
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
ADD_ARG_INT (&net_buf, req_handle->cursor_pos);
ADD_ARG_INT (&net_buf, req_handle->fetch_size);
ADD_ARG_BYTES (&net_buf, &flag, 1);
ADD_ARG_INT (&net_buf, result_set_index);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
err_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (err_code < 0)
{
return err_code;
}
num_tuple = decode_fetch_result (con_handle, req_handle, result_msg, result_msg + 4, result_msg_size - 4);
if (num_tuple < 0)
{
FREE_MEM (result_msg);
return num_tuple;
}
if (num_tuple != 0)
{
if (flag)
{
if (ut_is_deleted_oid (&(req_handle->tuple_value[0].tuple_oid)))
{
return CCI_ER_DELETED_TUPLE;
}
}
}
else
{
if (is_connected_to_oracle (con_handle) && req_handle->cursor_pos > req_handle->fetched_tuple_end
&& req_handle->is_fetch_completed)
{
return CCI_ER_NO_MORE_DATA;
}
}
return 0;
}
int
qe_get_data (T_CON_HANDLE * con_handle, T_REQ_HANDLE * req_handle, int col_no, int a_type, void *value, int *indicator)
{
char *col_value_p;
T_CCI_U_EXT_TYPE u_ext_type;
T_CCI_U_TYPE u_type;
int data_size;
int err_code;
int num_cols;
if (req_handle->is_closed)
{
return CCI_ER_RESULT_SET_CLOSED;
}
if (req_handle->stmt_type == CUBRID_STMT_CALL_SP)
{
num_cols = req_handle->num_bind + 1;
col_no++;
}
else
{
num_cols = req_handle->num_col_info;
}
if (col_no <= 0 || col_no > num_cols)
{
return CCI_ER_COLUMN_INDEX;
}
if (req_handle->cur_fetch_tuple_index < 0)
{
return CCI_ER_INVALID_CURSOR_POS;
}
col_value_p = req_handle->tuple_value[req_handle->cur_fetch_tuple_index].column_ptr[col_no - 1];
if (req_handle->stmt_type == CUBRID_STMT_CALL_SP)
{
u_ext_type = CCI_U_TYPE_NULL;
}
else
{
u_ext_type = CCI_GET_RESULT_INFO_TYPE (req_handle->col_info, col_no);
}
NET_STR_TO_INT (data_size, col_value_p);
if (data_size <= 0)
{
*indicator = -1;
if (a_type == CCI_A_TYPE_STR || a_type == CCI_A_TYPE_SET || a_type == CCI_A_TYPE_BLOB
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
return 0;
}
int
qe_schema_info (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, int type, char *arg1, char *arg2, char flag,
int shard_id, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_SCHEMA_INFO;
int err_code;
int result_code;
char *result_msg;
int result_msg_size;
T_BROKER_VERSION broker_ver;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, type);
if (arg1 == NULL)
ADD_ARG_BYTES (&net_buf, NULL, 0);
else
ADD_ARG_STR (&net_buf, arg1, strlen (arg1) + 1, con_handle->charset);
if (arg2 == NULL)
ADD_ARG_BYTES (&net_buf, NULL, 0);
else
ADD_ARG_STR (&net_buf, arg2, strlen (arg2) + 1, con_handle->charset);
ADD_ARG_BYTES (&net_buf, &flag, 1);
broker_ver = hm_get_broker_version (con_handle);
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V5))
{
ADD_ARG_INT (&net_buf, shard_id);
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
result_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (result_code < 0)
return result_code;
err_code = schema_info_decode (result_msg + 4, result_msg_size - 4, req_handle);
FREE_MEM (result_msg);
if (err_code < 0)
return err_code;
req_handle->handle_type = HANDLE_SCHEMA_INFO;
req_handle->handle_sub_type = type;
req_handle->server_handle_id = result_code;
req_handle->cur_fetch_tuple_index = -1;
req_handle->cursor_pos = 0;
req_handle->valid = 1;
return 0;
}
int
qe_oid_get (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char *oid_str, char **attr_name,
T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_OID_GET;
int err_code;
char *result_msg = NULL;
int result_msg_size;
int result_code;
int i;
T_OBJECT oid;
if (ut_str_to_oid (oid_str, &oid) < 0)
return CCI_ER_OBJECT;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_OBJECT (&net_buf, &oid);
if (attr_name)
{
for (i = 0; attr_name[i] != NULL; i++)
{
ADD_ARG_STR (&net_buf, attr_name[i], strlen (attr_name[i]) + 1, con_handle->charset);
}
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
result_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (result_code < 0)
return result_code;
err_code = oid_get_info_decode (result_msg + 4, result_msg_size - 4, req_handle, con_handle);
if (err_code < 0)
{
FREE_MEM (result_msg);
return err_code;
}
req_handle->handle_type = HANDLE_OID_GET;
req_handle->handle_sub_type = 0;
req_handle->msg_buf = result_msg;
return 0;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
return err_code;
}
int
qe_col_get (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char *oid_str, const char *col_attr, int *col_size,
int *col_type, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_COLLECTION;
char col_cmd = CCI_COL_GET;
int err_code;
T_OBJECT oid;
char *result_msg = NULL;
int result_msg_size;
if (ut_str_to_oid (oid_str, &oid) < 0)
{
return CCI_ER_OBJECT;
}
if (col_attr == NULL)
{
col_attr = "";
}
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_BYTES (&net_buf, &col_cmd, 1);
ADD_ARG_OBJECT (&net_buf, &oid);
ADD_ARG_STR (&net_buf, col_attr, strlen (col_attr) + 1, con_handle->charset);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
err_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (err_code < 0)
return err_code;
err_code = col_get_info_decode (result_msg + 4, result_msg_size - 4, col_size, col_type, req_handle, con_handle);
if (err_code < 0)
{
FREE_MEM (result_msg);
return err_code;
}
req_handle->handle_type = HANDLE_COL_GET;
req_handle->handle_sub_type = 0;
req_handle->msg_buf = result_msg;
req_handle->cursor_pos = 0;
return 0;
}
int
qe_get_row_count (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, int *row_count, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_GET_ROW_COUNT;
int err_code;
char *result_msg = NULL;
int result_msg_size;
int tmp;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
err_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (err_code < 0)
return err_code;
if (result_msg_size < 4)
{
FREE_MEM (result_msg);
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (tmp, result_msg + 4);
if (row_count)
{
*row_count = tmp;
}
return 0;
}
int
qe_get_last_insert_id (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, void *value, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_GET_LAST_INSERT_ID;
int err_code;
char *result_msg = NULL;
int result_msg_size;
int valsize = 0;
unsigned char type = 0;
char *ptr = NULL;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
return err_code;
err_code = net_recv_msg (con_handle, NULL, NULL, err_buf);
return err_code;
}
int
qe_next_result (T_REQ_HANDLE * req_handle, char flag, T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_NEXT_RESULT;
int err_code;
char *result_msg = NULL;
int result_msg_size;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
ADD_ARG_BYTES (&net_buf, &flag, 1);
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
{
return err_code;
}
err_code = net_recv_msg (con_handle, &result_msg, &result_msg_size, err_buf);
if (err_code < 0)
{
return err_code;
}
hm_req_handle_fetch_buf_free (req_handle);
err_code = next_result_info_decode (result_msg + 4, result_msg_size - 4, req_handle);
FREE_MEM (result_msg);
req_handle->cursor_pos = 0;
return err_code;
}
int
qe_execute_array (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, T_CCI_QUERY_RESULT ** qr, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_EXECUTE_ARRAY;
char autocommit_flag;
int err_code = 0;
T_BIND_VALUE cur_cell;
int row, idx;
char *result_msg = NULL;
char *msg;
int result_msg_size;
int remain_size;
int remaining_time = 0;
int shard_id;
T_BROKER_VERSION broker_ver;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
broker_ver = hm_get_broker_version (con_handle);
if (hm_broker_understand_the_protocol (broker_ver, PROTOCOL_V4))
{
if (TIMEOUT_IS_SET (con_handle))
{
remaining_time = con_handle->current_timeout;
remaining_time -= get_elapsed_time (&con_handle->start_time);
if (remaining_time <= 0)
{
net_buf_clear (&net_buf);
return CCI_ER_QUERY_TIMEOUT;
}
}
ADD_ARG_INT (&net_buf, remaining_time);
}
autocommit_flag = (char) con_handle->autocommit_mode;
ADD_ARG_BYTES (&net_buf, &autocommit_flag, 1);
for (row = 0; row < req_handle->bind_array_size; row++)
{
for (idx = 0; idx < req_handle->num_bind; idx++)
{
cur_cell.flag = BIND_PTR_STATIC;
cur_cell.value = NULL;
cur_cell.size = 0;
if (req_handle->bind_value[idx].value == NULL)
{
cur_cell.u_type = CCI_U_TYPE_NULL;
}
else if (req_handle->bind_value[idx].null_ind[row])
{
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
NET_STR_TO_INT (shard_id, msg);
remain_size -= NET_SIZE_INT;
msg += NET_SIZE_INT;
con_handle->shard_id = shard_id;
req_handle->shard_id = shard_id;
}
FREE_MEM (result_msg);
return err_code;
}
void
qe_query_result_free (int num_q, T_CCI_QUERY_RESULT * qr)
{
int i;
if (qr)
{
for (i = 0; i < num_q; i++)
FREE_MEM (qr[i].err_msg);
FREE_MEM (qr);
}
}
int
qe_query_result_copy (T_REQ_HANDLE * req_handle, T_CCI_QUERY_RESULT ** res_qr)
{
T_CCI_QUERY_RESULT *qr = NULL;
int num_query = req_handle->num_query_res;
int i;
*res_qr = NULL;
if (req_handle->qr == NULL || num_query == 0)
{
return 0;
}
qr = (T_CCI_QUERY_RESULT *) MALLOC (sizeof (T_CCI_QUERY_RESULT) * num_query);
if (qr == NULL)
{
return CCI_ER_NO_MORE_MEMORY;
}
for (i = 0; i < num_query; i++)
{
qr[i].result_count = req_handle->qr[i].result_count;
qr[i].stmt_type = req_handle->qr[i].stmt_type;
qr[i].err_no = req_handle->qr[i].err_no;
ALLOC_COPY (qr[i].err_msg, req_handle->qr[i].err_msg);
strcpy (qr[i].oid, req_handle->qr[i].oid);
}
*res_qr = qr;
return num_query;
}
int
qe_cursor_update (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, int cursor_pos, int index, T_CCI_A_TYPE a_type,
void *value, T_CCI_ERROR * err_buf)
{
T_NET_BUF net_buf;
char func_code = CAS_FC_CURSOR_UPDATE;
int err_code;
T_BIND_VALUE bind_value;
char u_type;
net_buf_init (&net_buf);
net_buf_cp_str (&net_buf, &func_code, 1);
ADD_ARG_INT (&net_buf, req_handle->server_handle_id);
ADD_ARG_INT (&net_buf, cursor_pos);
ADD_ARG_INT (&net_buf, index);
if (value == NULL)
{
bind_value.flag = BIND_PTR_STATIC;
bind_value.value = NULL;
bind_value.size = 0;
bind_value.u_type = CCI_U_TYPE_NULL;
}
else
{
if (req_handle->col_info == NULL)
{
net_buf_clear (&net_buf);
return CCI_ER_TYPE_CONVERSION;
}
u_type = get_basic_utype (req_handle->col_info[index - 1].ext_type);
if (u_type <= CCI_U_TYPE_FIRST || u_type > CCI_U_TYPE_LAST)
{
net_buf_clear (&net_buf);
return CCI_ER_TYPE_CONVERSION;
}
bind_value.flag = BIND_PTR_STATIC;
bind_value.value = NULL;
err_code =
bind_value_conversion (a_type, (T_CCI_U_TYPE) u_type, CCI_BIND_PTR, value, UNMEASURED_LENGTH, &bind_value);
if (err_code < 0)
{
net_buf_clear (&net_buf);
return err_code;
}
}
bind_value_to_net_buf (&net_buf, bind_value.u_type, bind_value.value, bind_value.size, con_handle->charset, false);
if (bind_value.flag == BIND_PTR_DYNAMIC)
{
FREE_MEM (bind_value.value);
}
if (net_buf.err_code < 0)
{
err_code = net_buf.err_code;
net_buf_clear (&net_buf);
return err_code;
}
err_code = net_send_msg (con_handle, net_buf.data, net_buf.data_size);
net_buf_clear (&net_buf);
if (err_code < 0)
{
return err_code;
}
err_code = net_recv_msg (con_handle, NULL, NULL, err_buf);
return err_code;
}
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
{
char *cur_p = buf;
int remain_size = *size;
int out_srv_handle_id;
char stmt_type;
int max_row;
char updatable_flag;
int num_col_info;
T_CCI_COL_INFO *col_info = NULL;
if (remain_size < NET_SIZE_INT)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (out_srv_handle_id, cur_p);
remain_size -= NET_SIZE_INT;
cur_p += NET_SIZE_INT;
if (remain_size < NET_SIZE_BYTE)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_BYTE (stmt_type, cur_p);
remain_size -= NET_SIZE_BYTE;
cur_p += NET_SIZE_BYTE;
if (remain_size < NET_SIZE_INT)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (max_row, cur_p);
remain_size -= NET_SIZE_INT;
cur_p += NET_SIZE_INT;
if (remain_size < NET_SIZE_BYTE)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_BYTE (updatable_flag, cur_p);
remain_size -= NET_SIZE_BYTE;
cur_p += NET_SIZE_BYTE;
num_col_info = get_column_info (cur_p, &remain_size, &col_info, NULL, true);
if (num_col_info < 0)
{
return num_col_info;
}
req_handle_col_info_free (req_handle);
req_handle->server_handle_id = out_srv_handle_id;
req_handle->handle_type = HANDLE_PREPARE;
req_handle->handle_sub_type = 0;
req_handle->num_tuple = max_row;
req_handle->num_col_info = num_col_info;
req_handle->col_info = col_info;
req_handle->stmt_type = (T_CCI_CUBRID_STMT) stmt_type;
req_handle->first_stmt_type = req_handle->stmt_type;
req_handle->updatable_flag = updatable_flag;
req_handle->cursor_pos = 0;
/**
* dummy. actually we don't need below information.
* if we don't make this, cci_close_query_result() will raise error.
*/
req_handle->num_query_res = 1;
req_handle->qr = (T_CCI_QUERY_RESULT *) MALLOC (sizeof (T_CCI_QUERY_RESULT));
if (req_handle->qr == NULL)
{
return CCI_ER_NO_MORE_MEMORY;
}
req_handle->qr[0].result_count = 1;
req_handle->qr[0].stmt_type = stmt_type;
req_handle->qr[0].err_no = 0;
req_handle->qr[0].err_msg = NULL;
return 0;
}
static int
get_cursor_pos (T_REQ_HANDLE * req_handle, int offset, char origin)
{
if (origin == CCI_CURSOR_FIRST)
{
return offset;
}
else if (origin == CCI_CURSOR_LAST)
{
return (req_handle->num_tuple - offset + 1);
}
return (req_handle->cursor_pos + offset);
}
static int
fetch_info_decode (char *buf, int size, int num_cols, T_TUPLE_VALUE ** tuple_value, T_FETCH_TYPE fetch_type,
T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle)
{
int remain_size = size;
char *cur_p = buf;
int err_code = 0;
int num_tuple, i, j;
T_TUPLE_VALUE *tmp_tuple_value = NULL;
char *charset = con_handle->charset;
if (fetch_type == FETCH_FETCH || fetch_type == FETCH_COL_GET)
{
if (remain_size < 4)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (num_tuple, cur_p);
remain_size -= 4;
cur_p += 4;
}
else
{
num_tuple = 1;
}
if (num_tuple < 0)
{
return 0;
}
else if (num_tuple == 0)
{
if (fetch_type == FETCH_FETCH && hm_get_broker_version (con_handle) >= CAS_PROTO_MAKE_VER (PROTOCOL_V5))
{
if (remain_size < NET_SIZE_BYTE)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_BYTE (req_handle->is_fetch_completed, cur_p);
remain_size -= NET_SIZE_BYTE;
cur_p += NET_SIZE_BYTE;
}
return 0;
}
tmp_tuple_value = (T_TUPLE_VALUE *) MALLOC (sizeof (T_TUPLE_VALUE) * num_tuple);
if (tmp_tuple_value == NULL)
return CCI_ER_NO_MORE_MEMORY;
memset ((char *) tmp_tuple_value, 0, sizeof (T_TUPLE_VALUE) * num_tuple);
for (i = 0; i < num_tuple; i++)
{
if (fetch_type == FETCH_FETCH)
{
if (remain_size < 4)
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
FREE_MEM (col_info[i].real_attr);
FREE_MEM (col_info[i].class_name);
FREE_MEM (col_info[i].default_value);
}
FREE_MEM (col_info);
}
return CCI_ER_COMMUNICATION;
}
static int
oid_get_info_decode (char *buf_p, int remain_size, T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle)
{
int num_col_info;
int class_name_size;
int err_code;
char *class_name;
char *cur_p = buf_p;
int size;
char *next_buf_p;
T_CCI_COL_INFO *col_info = NULL;
if (remain_size < NET_SIZE_INT)
return CCI_ER_COMMUNICATION;
NET_STR_TO_INT (class_name_size, cur_p);
remain_size -= NET_SIZE_INT;
cur_p += NET_SIZE_INT;
if (remain_size < class_name_size || class_name_size <= 0)
{
return CCI_ER_COMMUNICATION;
}
class_name = cur_p;
remain_size -= class_name_size;
cur_p += class_name_size;
size = remain_size;
num_col_info = get_column_info (cur_p, &size, &col_info, &next_buf_p, false);
if (num_col_info < 0)
{
assert (col_info == NULL);
return num_col_info;
}
req_handle->col_info = col_info;
req_handle->num_col_info = num_col_info;
remain_size -= CAST_STRLEN (next_buf_p - cur_p);
err_code =
fetch_info_decode (next_buf_p, remain_size, num_col_info, &(req_handle->tuple_value), FETCH_OID_GET, req_handle,
con_handle);
if (err_code < 0)
{
return err_code;
}
req_handle->fetched_tuple_end = req_handle->fetched_tuple_begin = 1;
req_handle->cur_fetch_tuple_index = 0;
req_handle->cursor_pos = 1;
return 0;
}
static int
schema_info_decode (char *buf_p, int size, T_REQ_HANDLE * req_handle)
{
T_CCI_COL_INFO *col_info = NULL;
int remain_size = size;
char *cur_p = buf_p;
int num_tuple;
int num_col_info;
if (remain_size < 4)
{
return CCI_ER_COMMUNICATION;
}
NET_STR_TO_INT (num_tuple, cur_p);
remain_size -= 4;
cur_p += 4;
size = remain_size;
num_col_info = get_column_info (cur_p, &size, &col_info, NULL, false);
if (num_col_info < 0)
{
assert (col_info == NULL);
return num_col_info;
}
req_handle->num_col_info = num_col_info;
req_handle->col_info = col_info;
req_handle->num_tuple = num_tuple;
return 0;
}
static int
col_get_info_decode (char *buf_p, int remain_size, int *col_size, int *col_type, T_REQ_HANDLE * req_handle,
T_CON_HANDLE * con_handle)
{
int num_col_info;
char *cur_p = buf_p;
char *next_buf_p;
T_CCI_COL_INFO *col_info = NULL;
int num_tuple;
int size;
if (remain_size < 1)
return CCI_ER_COMMUNICATION;
if (col_type)
{
*col_type = *cur_p;
}
remain_size -= 1;
cur_p += 1;
size = remain_size;
num_col_info = get_column_info (cur_p, &size, &col_info, &next_buf_p, false);
if (num_col_info < 0)
{
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
if (size < 2)
{
goto param_decode_error;
}
NET_STR_TO_SHORT (param[i].scale, buf);
size -= 2;
buf += 2;
if (size < 4)
{
goto param_decode_error;
}
NET_STR_TO_INT (param[i].precision, buf);
size -= 4;
buf += 4;
}
*res_param = param;
return 0;
param_decode_error:
qe_param_info_free (param);
return CCI_ER_COMMUNICATION;
}
static int
decode_fetch_result (T_CON_HANDLE * con_handle, T_REQ_HANDLE * req_handle, char *result_msg_org, char *result_msg_start,
int result_msg_size)
{
int num_cols;
int num_tuple;
if (req_handle->stmt_type == CUBRID_STMT_CALL_SP)
{
num_cols = req_handle->num_bind + 1;
}
else
{
num_cols = req_handle->num_col_info;
}
num_tuple =
fetch_info_decode (result_msg_start, result_msg_size, num_cols, &(req_handle->tuple_value), FETCH_FETCH, req_handle,
con_handle);
if (num_tuple < 0)
{
return num_tuple;
}
if (num_tuple == 0)
{
req_handle->fetched_tuple_begin = 0;
req_handle->fetched_tuple_end = 0;
req_handle->msg_buf = result_msg_org;
req_handle->cur_fetch_tuple_index = -1;
}
else
{
req_handle->fetched_tuple_begin = req_handle->cursor_pos;
req_handle->fetched_tuple_end = req_handle->cursor_pos + num_tuple - 1;
req_handle->msg_buf = result_msg_org;
req_handle->cur_fetch_tuple_index = 0;
}
return num_tuple;
}
#ifdef CCI_XA
static void
add_arg_xid (T_NET_BUF * net_buf, XID * xid)
{
net_buf_cp_int (net_buf, 12 + xid->gtrid_length + xid->bqual_length);
net_buf_cp_int (net_buf, xid->formatID);
net_buf_cp_int (net_buf, xid->gtrid_length);
net_buf_cp_int (net_buf, xid->bqual_length);
net_buf_cp_str (net_buf, xid->data, xid->gtrid_length + xid->bqual_length);
}
static int
xa_prepare_info_decode (char *buf, int buf_size, int count, XID * xid, int num_xid_buf)
{
int xid_data_size;
int i;
if (count > num_xid_buf)
count = num_xid_buf;
for (i = 0; i < count; i++)
{
if (buf_size < 4)
return CCI_ER_COMMUNICATION;
NET_STR_TO_INT (xid_data_size, buf);
buf += 4;
buf_size -= 4;
if (buf_size < xid_data_size)
return CCI_ER_COMMUNICATION;
net_str_to_xid (buf, &(xid[i]));
buf += xid_data_size;
buf_size -= xid_data_size;
}
return count;
}
static void
net_str_to_xid (char *buf, XID * xid)
{
memset (xid, 0, sizeof (XID));
NET_STR_TO_INT (xid->formatID, buf);
buf += 4;
NET_STR_TO_INT (xid->gtrid_length, buf);
buf += 4;
NET_STR_TO_INT (xid->bqual_length, buf);
buf += 4;
memcpy (xid->data, buf, xid->gtrid_length + xid->bqual_length);
}
#endif
static int
shard_info_decode (char *buf_p, int size, int num_shard, T_CCI_SHARD_INFO ** res_shard_info)
( run in 1.678 second using v1.01-cache-2.11-cpan-437f7b0c052 )