DBD-cubrid
view release on metacpan or search on metacpan
cci-src/src/cci/cas_cci.c view on Meta::CPAN
#define IS_OUT_TRAN_STATUS(CON_HANDLE) \
(IS_INVALID_SOCKET((CON_HANDLE)->sock_fd) || \
((CON_HANDLE)->con_status == CCI_CON_STATUS_OUT_TRAN))
#define IS_BROKER_STMT_POOL(c) \
((c)->broker_info[BROKER_INFO_STATEMENT_POOLING] == CAS_STATEMENT_POOLING_ON)
#define IS_OUT_TRAN(c) ((c)->con_status == CCI_CON_STATUS_OUT_TRAN)
#define IS_IN_TRAN(c) ((c)->con_status == CCI_CON_STATUS_IN_TRAN)
#define IS_FORCE_FAILBACK(c) ((c)->force_failback == 1)
#define IS_ER_COMMUNICATION(e) \
((e) == CCI_ER_COMMUNICATION || (e) == CAS_ER_COMMUNICATION)
#define IS_SERVER_DOWN(e) \
(((e) == ER_TM_SERVER_DOWN_UNILATERALLY_ABORTED) \
|| ((e) == ER_OBJ_NO_CONNECT) || ((e) == ER_NET_SERVER_CRASHED) \
|| ((e) == ER_BO_CONNECT_FAILED))
#define IS_ER_TO_RECONNECT(e1, e2) \
(((e1) == CCI_ER_DBMS && IS_SERVER_DOWN (e2)) ? true : IS_ER_COMMUNICATION (e1))
#define NEED_TO_RECONNECT(CON,ERR) \
(IS_ER_COMMUNICATION(ERR) || !hm_broker_reconnect_when_server_down(CON))
/* default value of each datesource property */
#define CCI_DS_POOL_SIZE_DEFAULT 10
#define CCI_DS_MAX_WAIT_DEFAULT 1000
#define CCI_DS_POOL_PREPARED_STATEMENT_DEFAULT false
#define CCI_DS_MAX_OPEN_PREPARED_STATEMENT_DEFAULT 1000
#define CCI_DS_DISCONNECT_ON_QUERY_TIMEOUT_DEFAULT false
#define CCI_DS_DEFAULT_AUTOCOMMIT_DEFAULT (CCI_AUTOCOMMIT_TRUE)
#define CCI_DS_DEFAULT_ISOLATION_DEFAULT TRAN_UNKNOWN_ISOLATION
#define CCI_DS_DEFAULT_LOCK_TIMEOUT_DEFAULT CCI_LOCK_TIMEOUT_DEFAULT
#define CCI_DS_LOGIN_TIMEOUT_DEFAULT (CCI_LOGIN_TIMEOUT_DEFAULT)
#define CON_HANDLE_ID_FACTOR 1000000
#define CON_ID(a) ((a) / CON_HANDLE_ID_FACTOR)
#define REQ_ID(a) ((a) % CON_HANDLE_ID_FACTOR)
/************************************************************************
* PRIVATE FUNCTION PROTOTYPES *
************************************************************************/
static void reset_error_buffer (T_CCI_ERROR * err_buf);
static int col_set_add_drop (int resolved_id, char col_cmd, char *oid_str, char *col_attr, char *value,
T_CCI_ERROR * err_buf);
static int col_seq_op (int resolved_id, char col_cmd, char *oid_str, char *col_attr, int index, const char *value,
T_CCI_ERROR * err_buf);
static int fetch_cmd (int reg_h_id, char flag, T_CCI_ERROR * err_buf);
static int cas_connect (T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf);
static int cas_connect_with_ret (T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf, int *connect);
static int cas_connect_internal (T_CON_HANDLE * con_handle, T_CCI_ERROR * err_buf, int *connect);
static int next_result_cmd (T_REQ_HANDLE * req_handle, T_CON_HANDLE * con_handle, char flag, T_CCI_ERROR * err_buf);
#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);
static int cci_time_string (char *buf, struct timeval *time_val);
static void set_error_buffer (T_CCI_ERROR * err_buf_p, int error, const char *message, ...);
static void copy_error_buffer (T_CCI_ERROR * dest_err_buf_p, T_CCI_ERROR * src_err_buf_p);
static int cci_datasource_release_internal (T_CCI_DATASOURCE * ds, T_CON_HANDLE * con_handle);
static int cci_end_tran_internal (T_CON_HANDLE * con_handle, char type);
static void get_last_error (T_CON_HANDLE * con_handle, T_CCI_ERROR * dest_err_buf);
static int convert_cas_mode_to_driver_mode (int cas_mode);
static int convert_driver_mode_to_cas_mode (int driver_mode);
/************************************************************************
* INTERFACE VARIABLES *
************************************************************************/
/************************************************************************
* PUBLIC VARIABLES *
************************************************************************/
/************************************************************************
* PRIVATE VARIABLES *
************************************************************************/
static const char *build_number = "VERSION=" MAKE_STR (BUILD_NUMBER);
#if defined(WINDOWS)
static HANDLE con_handle_table_mutex;
static HANDLE health_check_th_mutex;
#else
static T_MUTEX con_handle_table_mutex = PTHREAD_MUTEX_INITIALIZER;
static T_MUTEX health_check_th_mutex = PTHREAD_MUTEX_INITIALIZER;
#endif
static char init_flag = 0;
static char cci_init_flag = 1;
static char is_health_check_th_started = 0;
#if !defined(WINDOWS)
static int cci_SIGPIPE_ignore = 0;
#endif
static const char *datasource_key[] = {
CCI_DS_PROPERTY_USER,
CCI_DS_PROPERTY_PASSWORD,
CCI_DS_PROPERTY_URL,
CCI_DS_PROPERTY_POOL_SIZE,
CCI_DS_PROPERTY_MAX_WAIT,
CCI_DS_PROPERTY_POOL_PREPARED_STATEMENT,
CCI_DS_PROPERTY_MAX_OPEN_PREPARED_STATEMENT,
CCI_DS_PROPERTY_LOGIN_TIMEOUT,
CCI_DS_PROPERTY_QUERY_TIMEOUT,
CCI_DS_PROPERTY_DISCONNECT_ON_QUERY_TIMEOUT,
CCI_DS_PROPERTY_DEFAULT_AUTOCOMMIT,
cci-src/src/cci/cas_cci.c view on Meta::CPAN
if (error != CCI_ER_NO_ERROR)
{
return error;
}
reset_error_buffer (&(con_handle->err_buf));
API_SLOG (con_handle);
if (DOES_CONNECTION_HAVE_STMT_POOL (con_handle) && req_handle->sql_text != NULL)
{
qe_close_query_result (req_handle, con_handle);
/* free req_handle resources */
req_handle_content_free_for_pool (req_handle);
if (con_handle->autocommit_mode == CCI_AUTOCOMMIT_TRUE && IS_IN_TRAN (con_handle))
{
T_CCI_ERROR err_buf;
qe_end_tran (con_handle, CCI_TRAN_ROLLBACK, &err_buf);
}
error = hm_req_add_to_pool (con_handle, req_handle->sql_text, mapped_stmt_id, req_handle);
if (error == CCI_ER_NO_ERROR)
{
goto cci_close_req_handle_end;
}
}
if (req_handle->handle_type == HANDLE_PREPARE || req_handle->handle_type == HANDLE_SCHEMA_INFO)
{
error = qe_close_req_handle (req_handle, con_handle);
if (IS_ER_TO_RECONNECT (error, con_handle->err_buf.err_code))
{
if (IS_OUT_TRAN (con_handle))
{
error = CCI_ER_NO_ERROR;
}
}
}
else
{
error = CCI_ER_NO_ERROR;
}
hm_req_handle_free (con_handle, req_handle);
req_handle = NULL;
if (IS_OUT_TRAN (con_handle))
{
hm_check_rc_time (con_handle);
}
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)
{
T_CON_HANDLE *con_handle = NULL;
T_REQ_HANDLE *req_handle = NULL;
int error;
#ifdef CCI_FULL_DEBUG
CCI_DEBUG_PRINT (print_debug_msg
("(%d:%d)cci_fetch_size: %d", CON_ID (mapped_stmt_id), REQ_ID (mapped_stmt_id), fetch_size));
#endif
error = hm_get_statement (mapped_stmt_id, &con_handle, &req_handle);
if (error != CCI_ER_NO_ERROR)
{
return error;
}
req_handle->fetch_size = fetch_size;
con_handle->used = false;
return error;
}
int
cci_fetch (int mapped_stmt_id, T_CCI_ERROR * err_buf)
{
#ifdef CCI_FULL_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d:%d)cci_fetch", CON_ID (mapped_stmt_id), REQ_ID (mapped_stmt_id)));
#endif
return fetch_cmd (mapped_stmt_id, 0, err_buf);
}
int
cci_fetch_sensitive (int mapped_stmt_id, T_CCI_ERROR * err_buf)
{
#ifdef CCI_FULL_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d:%d)cci_fetch_sensitive", CON_ID (mapped_stmt_id), REQ_ID (mapped_stmt_id)));
#endif
return fetch_cmd (mapped_stmt_id, CCI_FETCH_SENSITIVE, err_buf);
}
int
cci_get_data (int mapped_stmt_id, int col_no, int a_type, void *value, int *indicator)
{
T_REQ_HANDLE *req_handle = NULL;
T_CON_HANDLE *con_handle = NULL;
int error = 0;
#ifdef CCI_FULL_DEBUG
cci-src/src/cci/cas_cci.c view on Meta::CPAN
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_col_set_drop", mapped_conn_id));
#endif
return col_set_add_drop (mapped_conn_id, CCI_COL_SET_DROP, oid_str, col_attr, value, err_buf);
}
int
cci_col_set_add (int mapped_conn_id, char *oid_str, char *col_attr, char *value, T_CCI_ERROR * err_buf)
{
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_col_set_add", mapped_conn_id));
#endif
return col_set_add_drop (mapped_conn_id, CCI_COL_SET_ADD, oid_str, col_attr, value, err_buf);
}
int
cci_col_seq_drop (int mapped_conn_id, char *oid_str, char *col_attr, int index, T_CCI_ERROR * err_buf)
{
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_coil_seq_drop", mapped_conn_id));
#endif
return col_seq_op (mapped_conn_id, CCI_COL_SEQ_DROP, oid_str, col_attr, index, "", err_buf);
}
int
cci_col_seq_insert (int mapped_conn_id, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR * err_buf)
{
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_col_seq_insert", mapped_conn_id));
#endif
return col_seq_op (mapped_conn_id, CCI_COL_SEQ_INSERT, oid_str, col_attr, index, value, err_buf);
}
int
cci_col_seq_put (int mapped_conn_id, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR * err_buf)
{
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_col_seq_put", mapped_conn_id));
#endif
return col_seq_op (mapped_conn_id, CCI_COL_SEQ_PUT, oid_str, col_attr, index, value, err_buf);
}
int
cci_query_result_free (T_CCI_QUERY_RESULT * qr, int num_q)
{
#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;
}
/*
* For the purpose of re-balancing existing connections, cci_prepare,
* cci_execute, cci_execute_array, cci_prepare_and_execute,
* cci_execute_batch require to forcefully disconnect the current
* con_handle when it is in the OUT_TRAN state and the time elapsed
* after the last failure of a host is over rc_time.
*/
int
cci_execute_batch (int mapped_conn_id, int num_query, char **sql_stmt, T_CCI_QUERY_RESULT ** qr, T_CCI_ERROR * err_buf)
{
T_CON_HANDLE *con_handle = NULL;
int error = CCI_ER_NO_ERROR;
#ifdef CCI_DEBUG
CCI_DEBUG_PRINT (print_debug_msg ("(%d)cci_execute_batch: %d", mapped_conn_id, num_query));
#endif
reset_error_buffer (err_buf);
if (qr == NULL || sql_stmt == NULL)
{
set_error_buffer (err_buf, CCI_ER_INVALID_ARGS, NULL);
return CCI_ER_INVALID_ARGS;
}
*qr = NULL;
error = hm_get_connection (mapped_conn_id, &con_handle);
if (error != CCI_ER_NO_ERROR)
{
set_error_buffer (err_buf, error, NULL);
return error;
}
reset_error_buffer (&(con_handle->err_buf));
con_handle->shard_id = CCI_SHARD_ID_INVALID;
if (num_query <= 0)
{
goto ret;
}
if (IS_OUT_TRAN (con_handle) && IS_FORCE_FAILBACK (con_handle) && !IS_INVALID_SOCKET (con_handle->sock_fd))
{
hm_force_close_connection (con_handle);
}
SET_START_TIME_FOR_QUERY (con_handle, NULL);
error = qe_execute_batch (con_handle, num_query, sql_stmt, qr, &(con_handle->err_buf));
while (IS_OUT_TRAN (con_handle) && IS_ER_TO_RECONNECT (error, con_handle->err_buf.err_code))
{
if (NEED_TO_RECONNECT (con_handle, error))
{
/* Finally, reset_connect will return ER_TIMEOUT */
cci-src/src/cci/cas_cci.c view on Meta::CPAN
error = hm_get_connection (mapped_conn_id, &con_handle);
if (error != CCI_ER_NO_ERROR)
{
set_error_buffer (err_buf, error, NULL);
return error;
}
reset_error_buffer (&(con_handle->err_buf));
req_handle_id = hm_req_handle_alloc (con_handle, &req_handle);
if (req_handle_id < 0)
{
error = req_handle_id;
goto ret;
}
error = qe_get_last_insert_id (req_handle, con_handle, value, &(con_handle->err_buf));
while (IS_OUT_TRAN (con_handle) && IS_ER_TO_RECONNECT (error, con_handle->err_buf.err_code))
{
if (NEED_TO_RECONNECT (con_handle, error))
{
/* Finally, reset_connect will return ER_TIMEOUT */
error = reset_connect (con_handle, NULL, &(con_handle->err_buf));
if (error != CCI_ER_NO_ERROR)
{
break;
}
}
error = qe_get_last_insert_id (req_handle, con_handle, value, &(con_handle->err_buf));
}
hm_req_handle_free (con_handle, req_handle);
req_handle = NULL;
ret:
set_error_buffer (&(con_handle->err_buf), error, NULL);
get_last_error (con_handle, err_buf);
con_handle->used = false;
return error;
}
static const char *
cci_get_err_msg_internal (int error)
{
switch (error)
{
case CCI_ER_DBMS:
case CAS_ER_DBMS:
return "CUBRID DBMS Error";
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";
case CCI_ER_BIND_INDEX:
return "Parameter index is out of range";
case CCI_ER_ATYPE:
return "Invalid T_CCI_A_TYPE value";
case CCI_ER_NOT_BIND:
return "Not used";
case CCI_ER_PARAM_NAME:
return "Invalid T_CCI_DB_PARAM value";
case CCI_ER_COLUMN_INDEX:
return "Column index is out of range";
case CCI_ER_SCHEMA_TYPE:
return "Not used";
case CCI_ER_FILE:
return "Cannot open file";
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";
case CCI_ER_OID_CMD:
return "Invalid T_CCI_OID_CMD value";
case CCI_ER_BIND_ARRAY_SIZE:
return "Array binding size is not specified";
case CCI_ER_ISOLATION_LEVEL:
return "Unknown transaction isolation level";
case CCI_ER_SET_INDEX:
return "Invalid set index";
case CCI_ER_DELETED_TUPLE:
return "Current row was deleted";
case CCI_ER_SAVEPOINT_CMD:
return "Invalid T_CCI_SAVEPOINT_CMD value";
case CCI_ER_THREAD_RUNNING:
return "Thread is running ";
case CCI_ER_INVALID_URL:
return "Invalid url string";
case CCI_ER_INVALID_LOB_READ_POS:
return "Invalid lob read position";
case CCI_ER_INVALID_LOB_HANDLE:
return "Invalid lob handle";
case CCI_ER_NO_PROPERTY:
return "Cannot find a property";
/* CCI_ER_INVALID_PROPERTY_VALUE equals to CCI_ER_PROPERTY_TYPE */
case CCI_ER_INVALID_PROPERTY_VALUE:
return "Invalid property value";
case CCI_ER_INVALID_DATASOURCE:
return "Invalid CCI datasource";
case CCI_ER_DATASOURCE_TIMEOUT:
return "All connections are used";
case CCI_ER_DATASOURCE_TIMEDWAIT:
return "pthread_cond_timedwait error";
case CCI_ER_LOGIN_TIMEOUT:
return "Connection timed out";
case CCI_ER_QUERY_TIMEOUT:
return "Request timed out";
case CCI_ER_RESULT_SET_CLOSED:
return "Result set is closed";
case CCI_ER_INVALID_HOLDABILITY:
return "Invalid holdability mode. The only accepted values are 0 or 1";
case CCI_ER_NOT_UPDATABLE:
return "Request handle is not updatable";
case CCI_ER_INVALID_ARGS:
return "Invalid argument";
case CCI_ER_USED_CONNECTION:
return "This connection is used already.";
case CCI_ER_NO_SHARD_AVAILABLE:
return "No shard available";
case CCI_ER_INVALID_SHARD:
return "Invalid shard";
case CAS_ER_INTERNAL:
return "Not used";
case CAS_ER_NO_MORE_MEMORY:
return "Memory allocation error";
case CAS_ER_COMMUNICATION:
return "Cannot receive data from client";
case CAS_ER_ARGS:
return "Invalid argument";
case CAS_ER_TRAN_TYPE:
return "Invalid transaction type argument";
case CAS_ER_SRV_HANDLE:
return "Server handle not found";
case CAS_ER_NUM_BIND:
return "Invalid parameter binding value argument";
case CAS_ER_UNKNOWN_U_TYPE:
return "Invalid T_CCI_U_TYPE value";
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";
case CAS_ER_VERSION:
return "Version mismatch";
case CAS_ER_FREE_SERVER:
return "Cannot process the request. Try again later";
case CAS_ER_NOT_AUTHORIZED_CLIENT:
return "Authorization error";
case CAS_ER_QUERY_CANCEL:
return "Cannot cancel the query";
case CAS_ER_NOT_COLLECTION:
return "The attribute domain must be the set type";
case CAS_ER_COLLECTION_DOMAIN:
return "Heterogeneous set is not supported";
case CAS_ER_NO_MORE_RESULT_SET:
return "No More Result";
case CAS_ER_INVALID_CALL_STMT:
return "Illegal CALL statement";
case CAS_ER_STMT_POOLING:
return "Invalid plan";
case CAS_ER_DBSERVER_DISCONNECTED:
return "Cannot communicate with DB Server";
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;
}
}
/*
Called by PRINT_CCI_ERROR()
*/
int
cci_get_error_msg (int error, T_CCI_ERROR * cci_err, char *buf, int bufsize)
{
const char *err_msg;
if ((buf == NULL) || (bufsize <= 0))
{
return -1;
}
err_msg = cci_get_err_msg_internal (error);
if (err_msg == NULL)
{
return -1;
}
else
{
if ((error < CCI_ER_DBMS) && (error > CCI_ER_END))
{
snprintf (buf, bufsize, "CCI Error : %s", err_msg);
}
else if ((error < CAS_ER_DBMS) && (error >= CAS_ER_IS))
{
snprintf (buf, bufsize, "CUBRID CAS Error : %s", err_msg);
}
if ((error == CCI_ER_DBMS) || (error == CAS_ER_DBMS))
{
if (cci_err == NULL)
{
snprintf (buf, bufsize, "%s ", err_msg);
}
else
{
snprintf (buf, bufsize, "%s : (%d) %s", err_msg, cci_err->err_code, cci_err->err_msg);
}
}
}
return 0;
}
/*
Called by applications.
They don't need prefix such as "ERROR :" or "CUBRID CAS ERROR".
*/
int
cci_get_err_msg (int error, char *buf, int bufsize)
{
cci-src/src/cci/cas_cci.c view on Meta::CPAN
case CCI_U_TYPE_FLOAT:
return "CCI_U_TYPE_FLOAT";
case CCI_U_TYPE_DOUBLE:
return "CCI_U_TYPE_DOUBLE";
case CCI_U_TYPE_DATE:
return "CCI_U_TYPE_DATE";
case CCI_U_TYPE_TIME:
return "CCI_U_TYPE_TIME";
case CCI_U_TYPE_TIMETZ:
return "CCI_U_TYPE_TIMETZ";
case CCI_U_TYPE_TIMESTAMP:
return "CCI_U_TYPE_TIMESTAMP";
case CCI_U_TYPE_TIMESTAMPTZ:
return "CCI_U_TYPE_TIMESTAMPTZ";
case CCI_U_TYPE_DATETIME:
return "CCI_U_TYPE_DATETIME";
case CCI_U_TYPE_DATETIMETZ:
return "CCI_U_TYPE_DATETIMETZ";
case CCI_U_TYPE_SET:
return "CCI_U_TYPE_SET";
case CCI_U_TYPE_MULTISET:
return "CCI_U_TYPE_MULTISET";
case CCI_U_TYPE_SEQUENCE:
return "CCI_U_TYPE_SEQUENCE";
case CCI_U_TYPE_OBJECT:
return "CCI_U_TYPE_OBJECT";
case CCI_U_TYPE_RESULTSET:
return "CCI_U_TYPE_RESULTSET";
case CCI_U_TYPE_BLOB:
return "CCI_U_TYPE_BLOB";
case CCI_U_TYPE_CLOB:
return "CCI_U_TYPE_CLOB";
case CCI_U_TYPE_USHORT:
return "CCI_U_TYPE_USHORT";
case CCI_U_TYPE_UINT:
return "CCI_U_TYPE_UINT";
case CCI_U_TYPE_UBIGINT:
return "CCI_U_TYPE_UBIGINT";
default:
return "***";
}
}
static const char *
dbg_db_param_str (T_CCI_DB_PARAM db_param)
{
switch (db_param)
{
case CCI_PARAM_ISOLATION_LEVEL:
return "CCI_PARAM_ISOLATION_LEVEL";
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 "***";
}
}
static const char *
dbg_sch_type_str (T_CCI_SCH_TYPE sch_type)
{
switch (sch_type)
{
case CCI_SCH_CLASS:
return "CCI_SCH_CLASS";
case CCI_SCH_VCLASS:
return "CCI_SCH_VCLASS";
case CCI_SCH_QUERY_SPEC:
return "CCI_SCH_QUERY_SPEC";
case CCI_SCH_ATTRIBUTE:
return "CCI_SCH_ATTRIBUTE";
case CCI_SCH_CLASS_ATTRIBUTE:
return "CCI_SCH_CLASS_ATTRIBUTE";
case CCI_SCH_METHOD:
return "CCI_SCH_METHOD";
case CCI_SCH_CLASS_METHOD:
return "CCI_SCH_CLASS_METHOD";
case CCI_SCH_METHOD_FILE:
return "CCI_SCH_METHOD_FILE";
case CCI_SCH_SUPERCLASS:
return "CCI_SCH_SUPERCLASS";
case CCI_SCH_SUBCLASS:
return "CCI_SCH_SUBCLASS";
case CCI_SCH_CONSTRAINT:
return "CCI_SCH_CONSTRAINT";
case CCI_SCH_TRIGGER:
return "CCI_SCH_TRIGGER";
case CCI_SCH_CLASS_PRIVILEGE:
return "CCI_SCH_CLASS_PRIVILEGE";
case CCI_SCH_ATTR_PRIVILEGE:
return "CCI_SCH_ATTR_PRIVILEGE";
case CCI_SCH_IMPORTED_KEYS:
return "CCI_SCH_IMPORTED_KEYS";
case CCI_SCH_EXPORTED_KEYS:
return "CCI_SCH_EXPORTED_KEYS";
case CCI_SCH_CROSS_REFERENCE:
return "CCI_SCH_CROSS_REFERENCE";
default:
return "***";
}
}
static const char *
dbg_oid_cmd_str (T_CCI_OID_CMD oid_cmd)
{
switch (oid_cmd)
( run in 0.570 second using v1.01-cache-2.11-cpan-5837b0d9d2c )