:meta-keywords: CCI driver, CCI api, cubrid cci :meta-description: CUBRID CCI API Reference for your C-based back-end application. CCI API 레퍼런스 ================ .. contents:: cci_bind_param -------------- .. c:function:: int cci_bind_param (int req_handle, int index, T_CCI_A_TYPE a_type, void *value, T_CCI_U_TYPE u_type, char flag) prepared statement에서 *bind* 변수에 데이터를 바인딩하기 위하여 사용되는 함수이다. 이때, 주어진 *a_type* 의 *value* 의 값을 실제 바인딩되어야 하는 타입으로 변환하여 저장한다. 이후, :c:func:`cci_execute`\ 가 호출될 때 저장된 데이터가 서버로 전송된다. 같은 *index* 에 대해서 여러 번 :c:func:`cci_bind_param`\ 을 호출할 경우 마지막으로 설정한 값이 유효하다. :param req_handle: (IN) prepared statement의 요청 핸들. :param index: (IN) 바인딩될 위치이며, 1부터 시작. :param a_type: (IN) *value* 의 타입. :param value: (IN) 바인딩될 데이터 값. :param u_type: (IN) 데이터베이스에 반영될 데이터 타입. :param flag: (IN) bind_flag(:c:type:`CCI_BIND_PTR`). :return: 에러 코드(0: 성공) * **CCI_ER_BIND_INDEX** * **CCI_ER_CON_HANDLE** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_REQ_HANDLE** * **CCI_ER_TYPE_CONVERSION** * **CCI_ER_USED_CONNECTION** 데이터베이스에 **NULL**\ 을 바인딩하려면 다음의 두 가지 중 하나를 설정한다. * *value* 값을 **NULL** 포인터로 설정 * *u_type*\ 을 :c:macro:`CCI_U_TYPE_NULL`\로 설정 다음은 NULL을 바인딩하는 코드의 일부이다. .. code-block:: c res = cci_bind_param (req, 2 /* binding index */, CCI_A_TYPE_STR, NULL, CCI_U_TYPE_STRING, CCI_BIND_PTR); 또는 .. code-block:: c res = cci_bind_param (req, 2 /* binding index */, CCI_A_TYPE_STR, data, CCI_U_TYPE_NULL, CCI_BIND_PTR); 가 사용될 수 있다. *flag*\에 :c:type:`CCI_BIND_PTR`\ 이 설정되어 있을 경우 *value* 변수의 포인터만 복사하고(shallow copy) 값은 복사하지 않는다. *flag*\가 설정되지 않는 경우 메모리를 할당하여 *value* 변수의 값을 복사(deep copy)한다. 만약 같은 메모리 버퍼를 이용하여 여러 개의 칼럼을 바인딩할 경우라면, :c:type:`CCI_BIND_PTR` *flag*\를 설정하지 않아야 한다. :c:type:`T_CCI_A_TYPE`\ 은 CCI 응용 프로그램 내에서 데이터 바인딩에 사용되는 C 언어의 타입을 의미하며, int, float 등의 primitive 타입과 :c:type:`T_CCI_BIT`, :c:type:`T_CCI_DATE` 등의 CCI 가 정의한 user-defined 타입으로 구성된다. 각 타입에 대한 식별자는 아래의 표와 같이 정의되어 있다. +-----------------------------+-----------------------------+ | a_type | value 타입 | +=============================+=============================+ | **CCI_A_TYPE_STR** | char \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_INT** | int \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_FLOAT** | float \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_DOUBLE** | double \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_BIT** | **T_CCI_BIT** \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_SET** | **T_CCI_SET** | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_DATE** | **T_CCI_DATE** \* | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_BIGINT** | int64_t \* | | | (For Windows: __int64 \*) | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_BLOB** | **T_CCI_BLOB** | +-----------------------------+-----------------------------+ | **CCI_A_TYPE_CLOB** | **T_CCI_CLOB** | +-----------------------------+-----------------------------+ :c:type:`T_CCI_U_TYPE`\ 은 데이터베이스의 칼럼 타입으로, value 인자를 통해 바인딩된 데이터를 이 타입으로 변환한다. :c:func:`cci_bind_param` 함수는 C 언어가 이해하는 A 타입의 데이터를 데이터베이스가 이해할 수 있는 U 타입의 데이터로 변환하기 위한 정보를 전달하기 위해서 두 가지 타입을 사용한다. U 타입이 허용하는 A 타입은 여러 가지이다. 예를 들어 **CCI_U_TYPE_INT** 는 **CCI_A_TYPE_INT** 외에 **CCI_A_TYPE_STR** 도 A 타입으로 받을 수 있다. 타입 변환은 :ref:`implicit-type-conversion`\ 을 따른다. :c:type:`T_CCI_A_TYPE` 및 :c:type:`T_CCI_U_TYPE` enum은 모두 **cas_cci.h** 파일에 정의되어 있다. 각 타입에 대한 식별자 정의는 아래 표를 참고한다. +--------------------------+-----------------------+ | u_type | 대응되는 기본 a_type | +==========================+=======================+ | **CCI_U_TYPE_CHAR** | **CCI_A_TYPE_STR** | +--------------------------+-----------------------+ | **CCI_U_TYPE_STRING** | **CCI_A_TYPE_STR** | +--------------------------+-----------------------+ | **CCI_U_TYPE_BIT** | **CCI_A_TYPE_BIT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_VARBIT** | **CCI_A_TYPE_BIT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_NUMERIC** | **CCI_A_TYPE_STR** | +--------------------------+-----------------------+ | **CCI_U_TYPE_INT** | **CCI_A_TYPE_INT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_SHORT** | **CCI_A_TYPE_INT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_FLOAT** | **CCI_A_TYPE_FLOAT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_DOUBLE** | **CCI_A_TYPE_DOUBLE** | +--------------------------+-----------------------+ | **CCI_U_TYPE_DATE** | **CCI_A_TYPE_DATE** | +--------------------------+-----------------------+ | **CCI_U_TYPE_TIME** | **CCI_A_TYPE_DATE** | +--------------------------+-----------------------+ | **CCI_U_TYPE_TIMESTAMP** | **CCI_A_TYPE_DATE** | +--------------------------+-----------------------+ | **CCI_U_TYPE_OBJECT** | **CCI_A_TYPE_STR** | +--------------------------+-----------------------+ | **CCI_U_TYPE_BIGINT** | **CCI_A_TYPE_BIGINT** | +--------------------------+-----------------------+ | **CCI_U_TYPE_DATETIME** | **CCI_A_TYPE_DATE** | +--------------------------+-----------------------+ | **CCI_U_TYPE_BLOB** | **CCI_A_TYPE_BLOB** | +--------------------------+-----------------------+ | **CCI_U_TYPE_CLOB** | **CCI_A_TYPE_CLOB** | +--------------------------+-----------------------+ | **CCI_U_TYPE_ENUM** | **CCI_A_TYPE_STR** | +--------------------------+-----------------------+ 날짜를 포함하는 문자열을 **DATE**, **DATETIME** 또는 **TIMESTAMP** 의 입력 인자로 할 때, 날짜 문자열의 형식은 "YYYY/MM/DD" 형식 또는 "YYYY-MM-DD" 형식만 허용한다. 즉, "2012/01/31" 또는 "2012-01-31"과 같은 형식은 허용하지만 "01/31/2012"와 같은 형식은 허용하지 않는다. 날짜를 포함하는 문자열을 날짜 타입의 입력 인자로 하는 예는 다음과 같다. .. code-block:: c // "CREATE TABLE tbl(aa date, bb datetime)"; char *values[][2] = { {"1994/11/30", "1994/11/30 20:08:08"}, {"2008-10-31", "2008-10-31 20:08:08"} }; req = cci_prepare(conn, "insert into tbl (aa, bb) values (?, ?)", CCI_PREPARE_INCLUDE_OID, &error); for(i=0; i< 2; i++) { res = cci_bind_param(req, 1, CCI_A_TYPE_STR, values[i][0], CCI_U_TYPE_DATE, (char)0); res = cci_bind_param(req, 2, CCI_A_TYPE_STR, values[i][1], CCI_U_TYPE_DATETIME, (char)0); cci_execute(req, CCI_EXEC_QUERY_ALL, 0, err_buf); } cci_bind_param_array -------------------- .. c:function:: int cci_bind_param_array(int req_handle, int index, T_CCI_A_TYPE a_type, void *value, int *null_ind, T_CCI_U_TYPE u_type) prepare된 *req_handle* 에 대해서 파라미터 배열을 바인딩한다. 이후, :c:func:`cci_execute_array`\ 가 호출될 때 저장된 *value* 포인터에 의해 데이터가 서버로 전송된다. 같은 *index* 에 대해서 여러 번 :c:func:`cci_bind_param_array`\ 가 호출될 경우 마지막 설정된 값이 유효하다. 데이터에 **NULL**\ 을 바인딩할 경우 *null_ind*\ 에 0이 아닌 값을 설정한다. *value* 값이 **NULL** 포인터인 경우, 또는 *u_type*\ 이 **CCI_U_TYPE_NULL**\ 인 경우 모든 데이터가 **NULL**\ 로 바인딩되며 *value*\ 에 의해 사용되는 데이터 버퍼는 재사용될 수 없다. *a_type*\ 에 대한 *value*\ 의 데이터 타입은 :c:func:`cci_bind_param`\ 의 설명을 참조한다. :param req_handle: (IN) prepared statement의 요청 핸들 :param index: (IN) 바인딩될 위치 :param a_type: (IN) *value* 의 타입 :param value: (IN) 바인딩될 데이터 값 :param null_ind: (IN) **NULL** 식별자 배열(0 : not **NULL**, 1 : **NULL**) :param u_type: (IN) 데이터베이스에 반영될 데이터 타입 :return: 에러 코드(0: 성공) * **CCI_ER_BIND_INDEX** * **CCI_ER_BIND_ARRAY_SIZE** * **CCI_ER_CON_HANDLE** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_REQ_HANDLE** * **CCI_ER_TYPE_CONVERSION** * **CCI_ER_USED_CONNECTION** cci_bind_param_array_size ------------------------- .. c:function:: int cci_bind_param_array_size(int req_handle, int array_size) :c:func:`cci_bind_param_array`\ 에서 사용될 array의 크기를 결정한다. :c:func:`cci_bind_param_array`\ 가 사용되기 전에 반드시 :c:func:`cci_bind_param_array_size`\ 가 먼저 호출 되어야 한다. :param req_handle: (IN) prepared statement의 요청 핸들 :param array_size: (IN) 바인딩할 배열 크기 :return: 에러 코드(0: 성공) * **CCI_ER_CON_HANDLE** * **CCI_ER_REQ_HANDLE** * **CCI_ER_USED_CONNECTION** cci_bind_param_ex ----------------- .. c:function:: int cci_bind_param_ex (int req_handle, int index, T_CCI_A_TYPE a_type, void *value, int length, T_CCI_U_TYPE u_type, char flag) :c:func:`cci_bind_param`\과 동일한 동작을 수행한다. 다만 문자열 타입인 경우 문자열의 바이트 길이를 지정하는 *length* 인자가 추가로 존재한다. :param req_handle: (IN) prepared statement의 요청 핸들 :param index: (IN) 바인딩될 위치이며, 1부터 시작 :param a_type: (IN) *value* 의 타입 :param value: (IN) 바인딩할 데이터 값 :param length: (IN) 바인딩할 문자열의 바이트 길이 :param u_type: (IN) 데이터베이스에 반영될 데이터 타입 :param flag: (IN) bind_flag(:c:type:`CCI_BIND_PTR`) :return: 에러 코드(0: 성공) *length* 인자는 아래와 같이 '\\0'을 포함하는 문자열을 바인딩하기 위해 사용할 수 있다. .. code-block:: c cci_bind_param_ex(req, 1, CCI_A_TYPE_STR, "aaa\0bbb", 7, CCI_U_TYPE_STRING, 0); cci_blob_free ------------- .. c:function:: int cci_blob_free(T_CCI_BLOB blob) **BLOB** 구조체에 대한 메모리를 해제한다. :return: 에러 코드(0: 성공) * **CCI_ER_INVALID_LOB_HANDLE** cci_blob_new ------------ .. c:function:: int cci_blob_new(int conn_handle, T_CCI_BLOB* blob, T_CCI_ERROR* error_buf) **LOB** 데이터가 저장될 빈 파일을 하나 생성하고, 해당 파일을 참조하는 Locator를 *blob* 구조체에 반환한다. :param conn_handle: (IN) 연결 핸들 :param blob: (OUT) **LOB** Locator :param error_buf: (OUT) 에러 버퍼 :return: 에러 코드(0: 성공) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_USED_CONNECTION** cci_blob_read ------------- .. c:function:: int cci_blob_read(int conn_handle, T_CCI_BLOB blob, long long start_pos, int length, char *buf, T_CCI_ERROR* error_buf) *blob* 에 명시한 **LOB** 데이터 파일의 *start_pos* 부터 *length* 만큼 데이터를 읽어 *buf* 에 저장한 후 이를 반환한다. :param conn_handle: (IN) 연결 핸들 :param blob: (IN) **LOB** Locator :param start_pos: (IN) **LOB** 데이터 파일의 위치 인덱스 :param length: (IN) 파일로부터 가져올 **LOB** 데이터 길이 :param buf: (IN) 데이터 읽기 버퍼 :param error_buf: (OUT) 에러 버퍼 :return: 에러 코드(0: 성공) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_INVALID_LOB_READ_POS** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_QUERY_TIMEOUT** * **CCI_ER_USED_CONNECTION** cci_blob_size ------------- .. c:function:: long long cci_blob_size(T_CCI_BLOB blob) *blob* 에 명시한 데이터 파일의 크기를 반환한다. :param blob: (IN) **LOB** Locator :return: **BLOB** 데이터 파일의 크기(>=0 : 성공), 에러 코드(<0 : 에러) * **CCI_ER_INVALID_LOB_HANDLE** cci_blob_write -------------- .. c:function:: int cci_blob_write(int conn_handle, T_CCI_BLOB blob, long long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf) *buf* 로부터 *length* 만큼 데이터를 읽어 *blob* 에 명시한 **LOB** 데이터 파일의 *start_pos* 부터 저장한다. :param conn_handle: (IN) 연결 핸들 :param blob: (IN) **LOB** Locator :param start_pos: (IN) **LOB** 데이터 파일의 위치 인덱스 :param length: (IN) 버퍼로부터 가져올 데이터 길이 :param buf: (OUT) 데이터 쓰기 버퍼 :param error_buf: (OUT) 에러 버퍼 :return: write한 크기(>=0 : 성공), 에러 코드(<0 : 에러) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_QUERY_TIMEOUT** * **CCI_ER_USED_CONNECTION** cci_cancel ---------- .. c:function:: int cci_cancel(int conn_handle) 다른 스레드에서 실행 중인 질의를 취소시킨다. Java의 Statement.cancel() 메서드와 같은 기능을 수행한다. :param conn_handle: (IN) 연결 핸들 :return: 에러 코드 * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** 다음은 main 함수에서 스레드의 질의 실행을 취소하는 예이다. .. code-block:: c /* gcc -o pthr pthr.c -m64 -I${CUBRID}/include -lnsl ${CUBRID}/lib/libcascci.so -lpthread */ #include #include #include #include #include #include #define QUERY "select * from db_class A, db_class B, db_class C, db_class D, db_class E" static void *thread_main (void *arg); static void *execute_statement (int con, char *sql_stmt); int main (int argc, char *argv[]) { int thr_id = 0, conn_handle = 0, res = 0; void *jret; pthread_t th; char url[1024]; T_CCI_ERROR error; snprintf (url, 1024, "cci:CUBRID:localhost:33000:demodb:PUBLIC::"); conn_handle = cci_connect_with_url_ex (url, NULL, NULL, &error); if (conn_handle < 0) { printf ("ERROR: %s\n", error.err_msg); return -1; } res = pthread_create (&th, NULL, &thread_main, (void *) &conn_handle); if (res < 0) { printf ("thread fork failed.\n"); return -1; } else { printf ("thread started\n"); } sleep (5); // If thread_main is still running, below cancels the query of thread_main. res = cci_cancel (conn_handle); if (res < 0) { printf ("cci_cancel failed\n"); return -1; } else { printf ("The query was canceled by cci_cancel.\n"); } res = pthread_join (th, &jret); if (res < 0) { printf ("thread join failed.\n"); return -1; } printf ("thread_main was cancelled with\n\t%s\n", (char *) jret); free (jret); res = cci_disconnect (conn_handle, &error); if (res < 0) { printf ("ERROR: %s\n", error.err_msg); return res; } return 0; } void * thread_main (void *arg) { int con = *((int *) arg); int ret_val; void *ret_ptr; T_CCI_ERROR error; cci_set_autocommit (con, CCI_AUTOCOMMIT_TRUE); ret_ptr = execute_statement (con, QUERY); return ret_ptr; } static void * execute_statement (int con, char *sql_stmt) { int col_count = 1, ind, i, req; T_CCI_ERROR error; char *buffer; char *error_msg; int res = 0; error_msg = (char *) malloc (128); if ((req = cci_prepare (con, sql_stmt, 0, &error)) < 0) { snprintf (error_msg, 128, "cci_prepare ERROR: %s\n", error.err_msg); goto conn_err; } if ((res = cci_execute (req, 0, 0, &error)) < 0) { snprintf (error_msg, 128, "cci_execute ERROR: %s\n", error.err_msg); goto execute_error; } if (res >= 0) { while (1) { res = cci_cursor (req, 1, CCI_CURSOR_CURRENT, &error); if (res == CCI_ER_NO_MORE_DATA) { break; } if (res < 0) { snprintf (error_msg, 128, "cci_cursor ERROR: %s\n", error.err_msg); return error_msg; } if ((res = cci_fetch (req, &error)) < 0) { snprintf (error_msg, 128, "cci_fetch ERROR: %s\n", error.err_msg); return error_msg; } for (i = 1; i <= col_count; i++) { if ((res = cci_get_data (req, i, CCI_A_TYPE_STR, &buffer, &ind)) < 0) { snprintf (error_msg, 128, "cci_get_data ERROR\n"); return error_msg; } } } } if ((res = cci_close_query_result (req, &error)) < 0) { snprintf (error_msg, 128, "cci_close_query_result ERROR: %s\n", error.err_msg); return error_msg; } execute_error: if ((res = cci_close_req_handle (req)) < 0) { snprintf (error_msg, 128, "cci_close_req_handle ERROR\n"); } conn_err: return error_msg; } cci_clob_free ------------- .. c:function:: int cci_clob_free(T_CCI_CLOB clob) **CLOB** 구조체에 대한 메모리를 해제한다. :param clob: (IN) **LOB** Locator :return: 에러 코드(0: 성공) * **CCI_ER_INVALID_LOB_HANDLE** cci_clob_new ------------ .. c:function:: int cci_clob_new(int conn_handle, T_CCI_CLOB* clob, T_CCI_ERROR* error_buf) **LOB** 데이터가 저장될 빈 파일을 하나 생성하고, 해당 파일을 참조하는 Locator를 *clob* 구조체에 반환한다. :param conn_handle: (IN) 연결 핸들 :param clob: (OUT) **LOB** Locator :param error_buf: (OUT) 에러 버퍼 :return: 에러 코드(<0 : 에러) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_USED_CONNECTION** cci_clob_read ------------- .. c:function:: int cci_clob_read(int conn_handle, T_CCI_CLOB clob, long start_pos, int length, char *buf, T_CCI_ERROR* error_buf) *clob* 에 명시한 **LOB** 데이터 파일의 *start_pos* 부터 *length* 만큼 데이터를 읽어 *buf* 에 저장한 후 이를 반환한다. :param conn_handle: (IN) 연결 핸들 :param clob: (IN) **LOB** Locator :param start_pos: (IN) **LOB** 데이터 파일의 위치 인덱스 :param length: (IN) 파일로부터 가져올 **LOB** 데이터 길이 :param buf: (IN) 데이터 읽기 버퍼 :param error_buf: (OUT) 에러 버퍼 :return: read한 크기(>=0 : 성공), 에러 코드(<0 : 에러) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_INVALID_LOB_READ_POS** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_QUERY_TIMEOUT** * **CCI_ER_USED_CONNECTION** cci_clob_size ------------- .. c:function:: long long cci_clob_size(T_CCI_CLOB* clob) *clob* 에 명시한 데이터 파일의 크기를 반환한다. :param clob: (IN) **LOB** Locator :return: **CLOB** 데이터 파일의 크기(>=0 : 성공), 에러 코드(<0 : 에러) * **CCI_ER_INVALID_LOB_HANDLE** cci_clob_write -------------- .. c:function:: int cci_clob_write(int conn_handle, T_CCI_CLOB clob, long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf) *buf* 로부터 *length* 만큼 데이터를 읽어 *clob* 에 명시한 **LOB** 데이터 파일의 *start_pos* 부터 저장한다. :param conn_handle: (IN) 연결 핸들 :param clob: (IN) **LOB** Locator :param start_pos: (IN) **LOB** 데이터 파일의 위치 인덱스 :param length: (IN) 버퍼로부터 가져올 데이터 길이 :param buf: (OUT) 데이터 쓰기 버퍼 :param error_buf: (OUT) 에러 버퍼 :return: write한 크기(>=0 : 성공), 에러 코드(<0 : 에러) * **CCI_ER_COMMUNICATION** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_INVALID_LOB_HANDLE** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_QUERY_TIMEOUT** * **CCI_ER_USED_CONNECTION** cci_close_query_result ---------------------- .. c:function:: int cci_close_query_result(int req_handle, T_CCI_ERROR *err_buf) :c:func:`cci_execute`, :c:func:`cci_execute_array` 또는 :c:func:`cci_execute_batch` 함수가 반환한 resultset을 종료(close)한다. 요청 핸들(req_handle)의 종료 없이 :c:func:`cci_prepare`\ 를 반복 수행하는 경우 :c:func:`cci_close_req_handle` 함수를 호출하기 전에 이 함수를 호출할 것을 권장한다. :param req_handle: (IN) 요청 핸들 :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 (0: 성공) * **CCI_ER_CON_HANDLE** * **CCI_ER_COMMUNICATION** * **CCI_ER_DBMS** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_REQ_HANDLE** * **CCI_ER_RESULT_SET_CLOSED** * **CCI_ER_USED_CONNECTION** cci_close_req_handle -------------------- .. c:function:: int cci_close_req_handle(int req_handle) :c:func:`cci_prepare`\ 로 획득한 요청 핸들을 종료(close)한다. :param req_handle: (IN) 요청 핸들 :return: 에러 코드(0 : 성공) * **CCI_ER_CON_HANDLE** * **CCI_ER_REQ_HANDLE** * **CCI_ER_COMMUNICATION** * **CCI_ER_DBMS** * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_USED_CONNECTION** cci_col_get ----------- .. c:function:: int cci_col_get (int conn_handle, char *oid_str, char *col_attr, int *col_size, int *col_type, T_CCI_ERROR *err_buf) collection type의 속성 값을 가져온다. 클래스 이름이 C이고 set_attr의 domain이 set(multiset, sequence)인 경우 다음의 질의와 같다. .. code-block:: sql SELECT a FROM C, TABLE(set_attr) AS t(a) WHERE C = oid; 즉, 멤버 개수가 레코드 개수가 된다. :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param col_size: (OUT) collection 크기 (-1 : null) :param col_type: (OUT) collection 타입 (set, multiset, sequence : u_type) :param err_buf: (OUT) 에러 버퍼 :return: 요청 핸들 * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_col_seq_drop ---------------- .. c:function:: int cci_col_seq_drop (int conn_handle, char *oid_str, char *col_attr, int index, T_CCI_ERROR *err_buf) sequence 속성 값에 index(base:1) 번째의 멤버를 drop시킨다. 다음은 seq 속성 값에서 첫 번째 값을 삭제하는 예이다. :: cci_col_seq_drop(conn_handle, oid_str, seq_attr, 1, err_buf); :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param index: (IN) 인덱스 :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_col_seq_insert ------------------ .. c:function:: int cci_col_seq_insert (int conn_handle, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR *err_buf) sequence 속성 값에서 index(base:1) 번째에 멤버를 추가시킨다. 다음은 seq 속성 값에서 1번에 값 'a'를 추가하는 예이다. :: cci_col_seq_insert(conn_handle, oid_str, seq_attr, 1, "a", err_buf); :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param index: (IN) 인덱스 :param value: (IN) 순차적 엘리먼트(스트링) :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_col_seq_put --------------- .. c:function:: int cci_col_seq_put (int conn_handle, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR *err_buf) sequence 속성 값에 index(base:1) 번째의 멤버를 새로운 값으로 대체한다.. 다음은 seq 속성 값에서 1번 값을 'a'로 대체하는 예이다. :: cci_col_seq_put(conn_handle, oid_str, seq_attr, 1, "a", err_buf); :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param index: (IN) 인덱스 :param value: (IN) 순차적 값 :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_col_set_add --------------- .. c:function:: int cci_col_set_add (int conn_handle, char *oid_str, char *col_attr, char *value, T_CCI_ERRROR *err_buf) set 속성 값에 member 하나를 추가한다. 다음은 set 속성 값에 'a'를 추가하는 예이다. :: cci_col_set_add(conn_handle, oid_str, set_attr, "a", err_buf); :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param value: (IN) set 엘리먼트 :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_col_set_drop ---------------- .. c:function:: int cci_col_set_drop (int conn_handle, char *oid_str, char *col_attr, char *value, T_CCI_ERROR *err_buf) set 속성 값에서 멤버 하나를 drop시킨다. 다음은 set 속성 값에서 'a'를 삭제하는 예이다. :: cci_col_set_drop(conn_handle, oid_str, set_attr, "a", err_buf); :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param value: (IN) set 엘리먼트(스트링) :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드 * **CCI_ER_CON_HANDLE** * **CCI_ER_QUERY_TIMEOUT** * **CCI_ER_LOGIN_TIMEOUT** * **CCI_ER_COMMUNICATION** cci_col_size ------------ .. c:function:: int cci_col_size (int conn_handle, char *oid_str, char *col_attr, int *col_size, T_CCI_ERROR *err_buf) set(seq) 속성의 개수를 가져온다. :param conn_handle: (IN) 연결 핸들 :param oid_str: (IN) oid :param col_attr: (IN) collection 속성 이름 :param col_size: (OUT) collection 크기 (-1 : NULL) :param err_buf: (OUT) 에러 버퍼 :return: 에러 코드(0 : 성공) * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_OBJECT** * **CCI_ER_DBMS** cci_connect ----------- .. c:function:: int cci_connect(char *ip, int port, char *db_name, char *db_user, char *db_password) DB 서버에 대한 연결 핸들을 할당받고 해당 서버와 연결을 시도한다. 서버 연결에 성공하면 연결 핸들 ID를 반환하고, 실패하면 에러 코드를 반환한다. :param ip: (IN) 서버 IP 문자 스트링 (호스트 이름) :param port: (IN) 브로커 포트( **$CUBRID/conf/cubrid_broker.conf** 파일에 설정된 포트를 사용) :param db_name: (IN) DB 이름 :param db_user: (IN) DB 사용자 이름 :param db_passwd: (IN) DB 사용자 암호 :return: 연결 핸들 ID(성공), 에러 코드(실패) * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_HOSTNAME** * **CCI_ER_CON_HANDLE** * **CCI_ER_DBMS** * **CCI_ER_COMMUNICATION** * **CCI_ER_CONNECT** cci_connect_ex -------------- .. c:function:: int cci_connect_ex(char *ip, int port, char *db_name, char *db_user, char *db_password, T_CCI_ERROR * err_buf) **CCI_ER_DBMS** 에러를 반환하면 세부 에러 내용을 DB 에러 버퍼(*err_buf*)를 통해 확인할 수 있다는 점만 :c:func:`cci_connect`\ 와 다르고 나머지는 동일하다. :param ip: (IN) 서버 IP 문자 스트링 (호스트 이름) :param port: (IN) 브로커 포트( **$CUBRID/conf/cubrid_broker.conf** 파일에 설정된 포트를 사용) :param db_name: (IN) DB 이름 :param db_user: (IN) DB 사용자 이름 :param db_passwd: (IN) DB 사용자 암호 :param err_buf: (OUT) 에러 버퍼 :return: 연결 핸들 ID(성공), 에러 코드(실패) * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_HOSTNAME** * **CCI_ER_CON_HANDLE** * **CCI_ER_DBMS** * **CCI_ER_COMMUNICATION** * **CCI_ER_CONNECT** cci_connect_with_url -------------------- .. c:function:: int cci_connect_with_url (char *url, char *db_user, char *db_password) *url* 인자로 전달된 접속 정보를 이용하여 데이터베이스로 연결을 시도한다. CCI에서 브로커의 HA 기능을 사용하는 경우 이 함수의 *url* 인자 내의 altHosts 속성을 이용하여, 장애 발생 시 failover할 standby 브로커 서버의 연결 정보를 명시해야 한다. 서버 연결에 성공하면 연결 핸들 ID를 반환하고, 실패하면 에러 코드를 반환한다. 브로커의 HA 기능에 대한 자세한 내용은 :ref:`duplexing-brokers`\를 참고한다. :param url: (IN) 서버 연결 정보 문자 스트링 :param db_user: (IN) DB 사용자 이름. NULL이면 *url* 의 <*db_user*>가 사용된다. 이 값이 빈 문자열("")이거나 *url* 내의 <*db_user*>가 정의되지 않은 경우 DB 사용자 이름은 **PUBLIC** 이 된다. :param db_passwd: (IN) DB 사용자 암호. NULL이면 *url* 의 <*db_password*>가 사용된다. *url* 내의 <*db_password*>가 정의되지 않은 경우 암호는 빈 문자열("")이 된다. :return: 연결 핸들 ID(성공), 에러 코드(실패) * **CCI_ER_NO_MORE_MEMORY** * **CCI_ER_HOSTNAME** * **CCI_ER_INVALID_URL** * **CCI_ER_CON_HANDLE** * **CCI_ER_CONNECT** * **CCI_ER_DBMS** * **CCI_ER_COMMUNICATION** * **CCI_ER_LOGIN_TIMEOUT** :: ::= cci:CUBRID::::::[?] ::= [&] ::= altHosts= [ &rcTime=