DBD-cubrid
view release on metacpan or search on metacpan
cci-src/src/cci/cas_cci.c view on Meta::CPAN
#if defined UNUSED_FUNCTION
static int cas_end_session (T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf);
#endif
#ifdef CCI_DEBUG
static void print_debug_msg (const char *format, ...);
static const char *dbg_tran_type_str (char type);
static const char *dbg_a_type_str (T_CCI_A_TYPE);
static const char *dbg_u_type_str (T_CCI_U_TYPE);
static const char *dbg_db_param_str (T_CCI_DB_PARAM db_param);
static const char *dbg_cursor_pos_str (T_CCI_CURSOR_POS cursor_pos);
static const char *dbg_sch_type_str (T_CCI_SCH_TYPE sch_type);
static const char *dbg_oid_cmd_str (T_CCI_OID_CMD oid_cmd);
static const char *dbg_isolation_str (T_CCI_TRAN_ISOLATION isol_level);
#endif
static const char *cci_get_err_msg_internal (int error);
static T_CON_HANDLE *get_new_connection (char *ip, int port, char *db_name, char *db_user, char *dbpasswd);
static bool cci_datasource_make_url (T_CCI_PROPERTIES * prop, char *new_url, char *url, T_CCI_ERROR * err_buf);
cci-src/src/cci/cas_cci.c view on Meta::CPAN
cci_close_req_handle_end:
API_ELOG (con_handle, error);
con_handle->used = false;
hm_release_statement (mapped_stmt_id, &con_handle, &req_handle);
return error;
}
int
cci_cursor (int mapped_stmt_id, int offset, T_CCI_CURSOR_POS origin, T_CCI_ERROR * err_buf)
{
T_REQ_HANDLE *req_handle = NULL;
T_CON_HANDLE *con_handle = NULL;
int error = CCI_ER_NO_ERROR;
#ifdef CCI_FULL_DEBUG
CCI_DEBUG_PRINT (print_debug_msg
("(%d:%d)cci_cursor: %d %s", CON_ID (mapped_stmt_id), REQ_ID (mapped_stmt_id), offset,
dbg_cursor_pos_str (origin)));
#endif
reset_error_buffer (err_buf);
error = hm_get_statement (mapped_stmt_id, &con_handle, &req_handle);
if (error != CCI_ER_NO_ERROR)
{
set_error_buffer (err_buf, error, NULL);
return error;
}
reset_error_buffer (&(con_handle->err_buf));
error = qe_cursor (req_handle, con_handle, offset, (char) origin, &(con_handle->err_buf));
set_error_buffer (&(con_handle->err_buf), error, NULL);
get_last_error (con_handle, err_buf);
con_handle->used = false;
return error;
}
int
cci_fetch_size (int mapped_stmt_id, int fetch_size)
cci-src/src/cci/cas_cci.c view on Meta::CPAN
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("cci_query_result_free"));
#endif
qe_query_result_free (num_q, qr);
return CCI_ER_NO_ERROR;
}
int
cci_cursor_update (int mapped_stmt_id, int cursor_pos, int index, T_CCI_A_TYPE a_type, void *value,
T_CCI_ERROR * err_buf)
{
int error = CCI_ER_NO_ERROR;
T_REQ_HANDLE *req_handle = NULL;
T_CON_HANDLE *con_handle = NULL;
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg
("(%d:%d)cci_cursor_update: %d %d %s %p", CON_ID (mapped_stmt_id), REQ_ID (mapped_stmt_id),
cursor_pos, index, dbg_a_type_str (a_type), value));
#endif
reset_error_buffer (err_buf);
error = hm_get_statement (mapped_stmt_id, &con_handle, &req_handle);
if (error != CCI_ER_NO_ERROR)
{
set_error_buffer (err_buf, error, NULL);
return error;
}
reset_error_buffer (&(con_handle->err_buf));
if ((req_handle->prepare_flag & CCI_PREPARE_UPDATABLE) == 0)
{
error = CCI_ER_NOT_UPDATABLE;
}
else
{
error = qe_cursor_update (req_handle, con_handle, cursor_pos, index, a_type, value, &(con_handle->err_buf));
}
set_error_buffer (&(con_handle->err_buf), error, NULL);
get_last_error (con_handle, err_buf);
con_handle->used = false;
return error;
}
/*
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CCI_ER_CON_HANDLE:
return "Invalid connection handle";
case CCI_ER_NO_MORE_MEMORY:
return "Memory allocation error";
case CCI_ER_COMMUNICATION:
return "Cannot communicate with server";
case CCI_ER_NO_MORE_DATA:
return "Invalid cursor position";
case CCI_ER_TRAN_TYPE:
return "Unknown transaction type";
case CCI_ER_STRING_PARAM:
return "Invalid string argument";
case CCI_ER_TYPE_CONVERSION:
return "Type conversion error";
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CCI_ER_CONNECT:
return "Cannot connect to CUBRID CAS";
case CCI_ER_ALLOC_CON_HANDLE:
return "Cannot allocate connection handle";
case CCI_ER_REQ_HANDLE:
return "Cannot allocate request handle";
case CCI_ER_INVALID_CURSOR_POS:
return "Invalid cursor position";
case CCI_ER_OBJECT:
return "Invalid oid string";
case CCI_ER_CAS:
return "Not used";
case CCI_ER_HOSTNAME:
return "Unknown host name";
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CAS_ER_DB_VALUE:
return "Cannot make DB_VALUE";
case CAS_ER_TYPE_CONVERSION:
return "Type conversion error";
case CAS_ER_PARAM_NAME:
return "Invalid T_CCI_DB_PARAM value";
case CAS_ER_NO_MORE_DATA:
return "Invalid cursor position";
case CAS_ER_OBJECT:
return "Invalid oid";
case CAS_ER_OPEN_FILE:
return "Cannot open file";
case CAS_ER_SCHEMA_TYPE:
return "Invalid T_CCI_SCH_TYPE value";
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CAS_ER_MAX_PREPARED_STMT_COUNT_EXCEEDED:
return "Cannot prepare more than MAX_PREPARED_STMT_COUNT statements";
case CAS_ER_HOLDABLE_NOT_ALLOWED:
return "Holdable results may not be updatable or sensitive";
case CAS_ER_MAX_CLIENT_EXCEEDED:
return "Proxy refused client connection. max clients exceeded";
case CAS_ER_INVALID_CURSOR_POS:
return "Invalid cursor position";
case CAS_ER_IS:
return "Not used";
default:
return NULL;
}
}
/*
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CCI_PARAM_LOCK_TIMEOUT:
return "CCI_PARAM_LOCK_TIMEOUT";
case CCI_PARAM_MAX_STRING_LENGTH:
return "CCI_PARAM_MAX_STRING_LENGTH";
default:
return "***";
}
}
static const char *
dbg_cursor_pos_str (T_CCI_CURSOR_POS cursor_pos)
{
switch (cursor_pos)
{
case CCI_CURSOR_FIRST:
return "CCI_CURSOR_FIRST";
case CCI_CURSOR_CURRENT:
return "CCI_CURSOR_CURRENT";
case CCI_CURSOR_LAST:
return "CCI_CURSOR_LAST";
default:
return "***";
}
cci-src/src/cci/cas_cci.h view on Meta::CPAN
T_CCI_U_TYPE u_type, char flag);
extern int cci_execute (int req_handle, char flag, int max_col_size, T_CCI_ERROR * err_buf);
extern int cci_prepare_and_execute (int con_handle, char *sql_stmt, int max_col_size, int *exec_retval,
T_CCI_ERROR * err_buf);
extern int cci_get_db_parameter (int con_handle, T_CCI_DB_PARAM param_name, void *value, T_CCI_ERROR * err_buf);
extern int cci_set_db_parameter (int con_handle, T_CCI_DB_PARAM param_name, void *value, T_CCI_ERROR * err_buf);
extern int cci_set_cas_change_mode (int mapped_conn_id, int mode, T_CCI_ERROR * err_buf);
extern long cci_escape_string (int con_h_id, char *to, const char *from, unsigned long length, T_CCI_ERROR * err_buf);
extern int cci_close_query_result (int req_handle, T_CCI_ERROR * err_buf);
extern int cci_close_req_handle (int req_handle);
extern int cci_cursor (int req_handle, int offset, T_CCI_CURSOR_POS origin, T_CCI_ERROR * err_buf);
extern int cci_fetch_size (int req_handle, int fetch_size);
extern int cci_fetch (int req_handle, T_CCI_ERROR * err_buf);
extern int cci_get_data (int req_handle, int col_no, int type, void *value, int *indicator);
extern int cci_schema_info (int con_handle, T_CCI_SCH_TYPE type, char *arg1, char *arg2, char flag,
T_CCI_ERROR * err_buf);
extern int cci_get_cur_oid (int req_handle, char *oid_str_buf);
extern int cci_oid_get (int con_handle, char *oid_str, char **attr_name, T_CCI_ERROR * err_buf);
extern int cci_oid_put (int con_handle, char *oid_str, char **attr_name, char **new_val, T_CCI_ERROR * err_buf);
extern int cci_oid_put2 (int con_h_id, char *oid_str, char **attr_name, void **new_val, int *a_type,
T_CCI_ERROR * err_buf);
cci-src/src/cci/cas_cci.h view on Meta::CPAN
extern int cci_is_updatable (int req_h_id);
extern int cci_is_holdable (int req_h_id);
extern int cci_next_result (int req_h_id, T_CCI_ERROR * err_buf);
extern int cci_bind_param_array_size (int req_h_id, int array_size);
extern int cci_bind_param_array (int req_h_id, int index, T_CCI_A_TYPE a_type, void *value, int *null_ind,
T_CCI_U_TYPE u_type);
extern int cci_execute_array (int req_h_id, T_CCI_QUERY_RESULT ** qr, T_CCI_ERROR * err_buf);
extern int cci_query_result_free (T_CCI_QUERY_RESULT * qr, int num_q);
extern int cci_fetch_sensitive (int req_h_id, T_CCI_ERROR * err_buf);
extern int cci_cursor_update (int req_h_id, int cursor_pos, int index, T_CCI_A_TYPE a_type, void *value,
T_CCI_ERROR * err_buf);
extern int cci_execute_batch (int con_h_id, int num_query, char **sql_stmt, T_CCI_QUERY_RESULT ** qr,
T_CCI_ERROR * err_buf);
extern int cci_fetch_buffer_clear (int req_h_id);
extern int cci_execute_result (int req_h_id, T_CCI_QUERY_RESULT ** qr, T_CCI_ERROR * err_buf);
extern int cci_set_isolation_level (int con_id, T_CCI_TRAN_ISOLATION val, T_CCI_ERROR * err_buf);
extern int cci_set_lock_timeout (int con_id, int val, T_CCI_ERROR * err_buf);
extern void cci_set_free (T_CCI_SET set);
extern int cci_set_size (T_CCI_SET set);
cci-src/src/cci/cci_handle_mng.h view on Meta::CPAN
T_CCI_CUBRID_STMT stmt_type;
T_CCI_CUBRID_STMT first_stmt_type;
int num_bind;
T_BIND_VALUE *bind_value;
char *bind_mode;
T_CCI_COL_INFO *col_info;
int bind_array_size;
int num_col_info;
int fetch_size;
char *msg_buf;
int cursor_pos;
int fetched_tuple_begin;
int fetched_tuple_end;
int cur_fetch_tuple_index;
T_TUPLE_VALUE *tuple_value;
T_VALUE_BUF conv_value_buffer;
T_CCI_QUERY_RESULT *qr;
int num_query_res;
int current_query_res;
int valid;
int query_timeout;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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);
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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);
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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);
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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)
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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);
}
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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
{
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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)
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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);
}
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
{
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)
{
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
{
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;
}
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
{
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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;
cci-src/src/cci/cci_query_execute.c view on Meta::CPAN
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)
cci-src/src/cci/cci_query_execute.h view on Meta::CPAN
extern int qe_end_tran (T_CON_HANDLE * con_handle, char type, T_CCI_ERROR * err_buf);
extern int qe_end_session (T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf);
extern int qe_get_db_parameter (T_CON_HANDLE * con_handle, T_CCI_DB_PARAM param_name, void *value,
T_CCI_ERROR * err_buf);
extern int qe_set_db_parameter (T_CON_HANDLE * con_handle, T_CCI_DB_PARAM param_name, void *value,
T_CCI_ERROR * err_buf);
extern int qe_set_cas_change_mode (T_CON_HANDLE * con_handle, int mode, T_CCI_ERROR * err_buf);
extern int qe_close_query_result (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle);
extern int qe_close_req_handle (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle);
extern void qe_close_req_handle_all (T_CON_HANDLE * con_handle);
extern int qe_cursor (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, int offset, char origin,
T_CCI_ERROR * err_buf);
extern int qe_fetch (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char flag, int result_set_index,
T_CCI_ERROR * err_buf);
extern int qe_get_data (T_CON_HANDLE * con_handle, T_REQ_HANDLE * req_handle, int col_no, int a_type, void *value,
int *indicator);
extern int qe_get_cur_oid (T_REQ_HANDLE * req_handle, char *oid_str_buf);
extern 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);
extern 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);
cci-src/src/cci/cci_query_execute.h view on Meta::CPAN
T_CCI_ERROR * err_buf);
extern int qe_col_set_add_drop (T_CON_HANDLE * con_handle, char col_cmd, char *oid_str, const char *col_attr,
char *value, T_CCI_ERROR * err_buf);
extern int qe_col_seq_op (T_CON_HANDLE * con_handle, char col_cmd, char *oid_str, const char *col_attr, int index,
const char *value, T_CCI_ERROR * err_buf);
extern int qe_next_result (T_REQ_HANDLE * req_handle, char flag, T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf);
extern int qe_execute_array (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, T_CCI_QUERY_RESULT ** qr,
T_CCI_ERROR * err_buf);
extern void qe_query_result_free (int num_q, T_CCI_QUERY_RESULT * qr);
extern 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);
extern int qe_execute_batch (T_CON_HANDLE * con_handle, int num_query, char **sql_stmt, T_CCI_QUERY_RESULT ** qr,
T_CCI_ERROR * err_buf);
extern int qe_query_result_copy (T_REQ_HANDLE * req_handle, T_CCI_QUERY_RESULT ** res_qr);
extern int qe_get_data_str (T_VALUE_BUF * conv_val_buf, T_CCI_U_TYPE u_type, char *col_value_p, int col_val_size,
void *value, int *indicator);
extern int qe_get_data_bigint (T_CCI_U_TYPE u_type, char *col_value_p, void *value);
extern int qe_get_data_ubigint (T_CCI_U_TYPE u_type, char *col_value_p, void *value);
extern int qe_get_data_int (T_CCI_U_TYPE u_type, char *col_value_p, void *value);
cci-src/win/cascci/cascci.def view on Meta::CPAN
cci_prepare
cci_get_bind_num
cci_get_result_info
cci_bind_param
cci_execute
cci_prepare_and_execute
cci_get_db_parameter
cci_set_db_parameter
cci_close_query_result
cci_close_req_handle
cci_cursor
cci_fetch_size
cci_fetch
cci_get_data
cci_schema_info
cci_get_cur_oid
cci_oid_get
cci_oid_put
cci_oid_put2
cci_get_db_version
cci_get_class_num_objs
cci-src/win/cascci/cascci.def view on Meta::CPAN
cci_col_seq_insert
cci_col_seq_put
cci_is_updatable
cci_is_holdable
cci_next_result
cci_bind_param_array_size
cci_bind_param_array
cci_execute_array
cci_query_result_free
cci_fetch_sensitive
cci_cursor_update
cci_execute_batch
cci_fetch_buffer_clear
cci_execute_result
cci_set_isolation_level
cci_set_lock_timeout
cci_set_free
cci_set_size
cci_set_element_type
cci_set_get
cci_set_make
goto ER_DB_PING;
}
req_handle = res;
if ((res = cci_execute (req_handle, 0, 0, &error)) < 0) {
goto ER_DB_PING;
}
while (1) {
res = cci_cursor (req_handle, 1, CCI_CURSOR_CURRENT, &error);
if (res == CCI_ER_NO_MORE_DATA) {
break;
}
if (res < 0) {
goto ER_DB_PING;
}
if ((res = cci_fetch (req_handle, &error)) < 0) {
goto ER_DB_PING;
}
case SQLX_CMD_DELETE:
case SQLX_CMD_CALL:
case SQLX_CMD_SELECT:
imp_sth->affected_rows = res;
break;
default:
imp_sth->affected_rows = -1;
}
if (sql_type == SQLX_CMD_SELECT) {
res = cci_cursor (imp_sth->handle, 1, CCI_CURSOR_CURRENT, &error);
if (res < 0 && res != CCI_ER_NO_MORE_DATA) {
handle_error (sth, res, &error);
return -2;
}
DBIc_NUM_FIELDS (imp_sth) = col_count;
DBIc_ACTIVE_on (imp_sth);
}
return imp_sth->affected_rows;
dbd_st_fetch( SV *sth, imp_sth_t *imp_sth )
{
AV *av;
int res;
T_CCI_ERROR error;
if (DBIc_ACTIVE(imp_sth)) {
DBIc_ACTIVE_off(imp_sth);
}
res = cci_cursor (imp_sth->handle, 0, CCI_CURSOR_CURRENT, &error);
if (res == CCI_ER_NO_MORE_DATA) {
return Nullav;
} else if (res < 0) {
goto ERR_ST_FETCH;
}
if ((res = cci_fetch (imp_sth->handle, &error)) < 0) {
goto ERR_ST_FETCH;
}
av = DBIS->get_fbav(imp_sth);
if ((res = _cubrid_fetch_row (av,
imp_sth->handle,
imp_sth->col_count,
imp_sth->col_info,
&error)) < 0) {
goto ERR_ST_FETCH;
}
res = cci_cursor (imp_sth->handle, 1, CCI_CURSOR_CURRENT, &error);
if (res < 0 && res != CCI_ER_NO_MORE_DATA) {
goto ERR_ST_FETCH;
}
return av;
ERR_ST_FETCH:
handle_error (sth, res, &error);
return Nullav;
}
handle_error (sth, CCI_ER_COLUMN_INDEX, NULL);
return FALSE;
}
u_type = CCI_GET_RESULT_INFO_TYPE (imp_sth->col_info, imp_sth->col_selected);
if (!(u_type == CCI_U_TYPE_BLOB || u_type == CCI_U_TYPE_CLOB)) {
handle_error (sth, CUBRID_ER_NOT_LOB_TYPE, NULL);
return FALSE;
}
res = cci_cursor (imp_sth->handle, index, CCI_CURSOR_FIRST, &error);
if (res == CCI_ER_NO_MORE_DATA) {
return TRUE;
} else if (res < 0) {
handle_error (sth, res, &error);
return FALSE;
}
if ((res = cci_fetch(imp_sth->handle, &error)) < 0) {
handle_error (sth, res, &error);
return FALSE;
int col_count,
T_CCI_COL_INFO *col_info,
T_CCI_ERROR *error )
{
int res;
while (1) {
AV *copy_row, *fetch_av;
int i = 0;
res = cci_cursor (req_handle, 1, CCI_CURSOR_CURRENT, error);
if (res == CCI_ER_NO_MORE_DATA) {
break;
}
else if (res < 0) {
return res;
}
if ((res = cci_fetch (req_handle, error)) < 0) {
return res;
}
( run in 0.556 second using v1.01-cache-2.11-cpan-4d50c553e7e )