CCI Driver¶

CCI Overview¶

CUBRID CCI (CCI Client Interface) driver implements an interface to enable access from C-based application to CUBRID database server through broker. It is also used as back-end infrastructure for creating tools (PHP, ODBC, etc.) which use the CAS application servers. In this environment, the CUBRID broker sends queries received from applications to a database and transfers the result to applications.

It is automatically installed upon CUBRID installation and can be found in the $CUBRID/lib directory. A header file as well as library files is required to use the driver.

Because CUBRID CCI driver is connected through the CUBRID broker, you can manage it the same way as other interfaces such as JDBC, PHP, ODBC, etc. In fact, CCI provides back-end infrastructure to implement PHP, ODBC, Python, and Ruby interfaces.

To download CCI driver or get the latest information, click http://www.cubrid.org/wiki_apis/entry/cubrid-cci-driver .

CCI Programming¶

//Example to execute a simple query
#include <stdio.h>
#include "cas_cci.h"
#define BUFSIZE  (1024)

int
main (void)
{
    int con = 0, req = 0, col_count = 0, i, ind;
    int error;
    char *data;
    T_CCI_ERROR cci_error;
    T_CCI_COL_INFO *col_info;
    T_CCI_CUBRID_STMT stmt_type;
    char *query = "select * from code";

    //getting a connection handle for a connection with a server
    con = cci_connect ("localhost", 33000, "demodb", "dba", "");
    if (con < 0)
    {
        printf ("cannot connect to database\n");
        return 1;
    }

    //preparing the SQL statement
    req = cci_prepare (con, query, 0, &cci_error);
    if (req < 0)
    {
        printf ("prepare error: %d, %s\n", cci_error.err_code,
            cci_error.err_msg);
        goto handle_error;
    }

    //getting column information when the prepared statement is the SELECT query
    col_info = cci_get_result_info (req, &stmt_type, &col_count);
    if (col_info == NULL)
    {
        printf ("get_result_info error: %d, %s\n", cci_error.err_code,
            cci_error.err_msg);
        goto handle_error;
    }

    //Executing the prepared SQL statement
    error = cci_execute (req, 0, 0, &cci_error);
    if (error < 0)
    {
        printf ("execute error: %d, %s\n", cci_error.err_code,
            cci_error.err_msg);
        goto handle_error;
    }
    while (1)
    {

        //Moving the cursor to access a specific tuple of results
        error = cci_cursor (req, 1, CCI_CURSOR_CURRENT, &cci_error);
        if (error == CCI_ER_NO_MORE_DATA)
        {
            break;
        }
        if (error < 0)
        {
            printf ("cursor error: %d, %s\n", cci_error.err_code,
                    cci_error.err_msg);
            goto handle_error;
        }

        //Fetching the query result into a client buffer
        error = cci_fetch (req, &cci_error);
        if (error < 0)
        {
            printf ("fetch error: %d, %s\n", cci_error.err_code,
                    cci_error.err_msg);
            goto handle_error;
        }
        for (i = 1; i <= col_count; i++)
        {

            //Getting data from the fetched result
            error = cci_get_data (req, i, CCI_A_TYPE_STR, &data, &ind);
            if (error < 0)
            {
                printf ("get_data error: %d, %d\n", error, i);
                goto handle_error;
            }
            printf ("%s\t|", data);
        }
        printf ("\n");
    }

    //Closing the request handle
    error = cci_close_req_handle (req);
    if (error < 0)
    {
        printf ("close_req_handle error: %d, %s\n", cci_error.err_code,
            cci_error.err_msg);
        goto handle_error;
    }

    //Disconnecting with the server
    error = cci_disconnect (con, &cci_error);
    if (error < 0)
    {
        printf ("error: %d, %s\n", cci_error.err_code, cci_error.err_msg);
        goto handle_error;
    }

    return 0;

handle_error:
    if (req > 0)
        cci_close_req_handle (req);
    if (con > 0)
        cci_disconnect (con, &cci_error);

    return 1;
}

//Example to execute a query with a bind variable

char *query = "select * from nation where name = ?";
char namebuf[128];

//getting a connection handle for a connection with a server
con = cci_connect ("localhost", 33000, "demodb", "dba", "");
if (con < 0)
{
    printf ("cannot connect to database ");
    return 1;
}

//preparing the SQL statement
req = cci_prepare (con, query, 0, &cci_error);
if (req < 0)
{
    printf ("prepare error: %d, %s ", cci_error.err_code,
            cci_error.err_msg);
        goto handle_error;
}

//Binding date into a value
strcpy (namebuf, "Korea");
error =
    cci_bind_param (req, 1, CCI_A_TYPE_STR, namebuf, CCI_U_TYPE_STRING,
                    CCI_BIND_PTR);
if (error < 0)
{
    printf ("bind_param error: %d ", error);
    goto handle_error;
}

#include <stdio.h>
#include "cas_cci.h"

//Example to use connection/statement pool in CCI
int main ()
{
    T_CCI_PROPERTIES *ps = NULL;
    T_CCI_DATASOURCE *ds = NULL;
    T_CCI_ERROR err;
    T_CCI_CONN cons[20];
    int rc = 1, i;

    ps = cci_property_create ();
    if (ps == NULL)
    {
        fprintf (stderr, "Could not create T_CCI_PROPERTIES.\n");
        rc = 0;
        goto cci_pool_end;
    }

    cci_property_set (ps, "user", "dba");
    cci_property_set (ps, "url", "cci:cubrid:localhost:33000:demodb:::");
    cci_property_set (ps, "pool_size", "10");
    cci_property_set (ps, "max_wait", "1200");
    cci_property_set (ps, "pool_prepared_statement", "true");
    cci_property_set (ps, "default_autocommit", "false");
    cci_property_set (ps, "default_isolation", "TRAN_REP_CLASS_UNCOMMIT_INSTANCE");
    cci_property_set (ps, "default_lock_timeout", "10");
    cci_property_set (ps, "login_timeout", "300000");
    cci_property_set (ps, "query_timeout", "3000");

    ds = cci_datasource_create (ps, &err);
    if (ds == NULL)
    {
        fprintf (stderr, "Could not create T_CCI_DATASOURCE.\n");
        fprintf (stderr, "E[%d,%s]\n", err.err_code, err.err_msg);
        rc = 0;
        goto cci_pool_end;
    }

    for (i = 0; i < 3; i++)
    {
        cons[i] = cci_datasource_borrow (ds, &err);
        if (cons[i] < 0)
        {
            fprintf (stderr,
                    "Could not borrow a connection from the data source.\n");
            fprintf (stderr, "E[%d,%s]\n", err.err_code, err.err_msg);
            continue;
        }
        // put working code here.
        cci_work (cons[i]);
    }

    sleep (1);

    for (i = 0; i < 3; i++)
    {
        if (cons[i] < 0)
        {
            continue;
        }
        cci_datasource_release (ds, cons[i], &err);
    }

cci_pool_end:
    cci_property_destroy (ps);
    cci_datasource_destroy (ds);

    return 0;
}

// working code
int cci_work (T_CCI_CONN con)
{
    T_CCI_ERROR err;
    char sql[4096];
    int req, res, error, ind;
    int data;

    cci_set_autocommit (con, CCI_AUTOCOMMIT_TRUE);
    cci_set_lock_timeout (con, 100, &err);
    cci_set_isolation_level (con, TRAN_REP_CLASS_COMMIT_INSTANCE, &err);

    error = 0;
    snprintf (sql, 4096, "SELECT host_year FROM record WHERE athlete_code=11744");
    req = cci_prepare (con, sql, 0, &err);
    if (req < 0)
    {
        printf ("prepare error: %d, %s\n", err.err_code, err.err_msg);
        return error;
    }

    res = cci_execute (req, 0, 0, &err);
    if (res < 0)
    {
        printf ("execute error: %d, %s\n", err.err_code, err.err_msg);
        goto cci_work_end;
    }

    while (1)
    {
    error = cci_cursor (req, 1, CCI_CURSOR_CURRENT, &err);
    if (error == CCI_ER_NO_MORE_DATA)
    {
        break;
    }
    if (error < 0)
    {
        printf ("cursor error: %d, %s\n", err.err_code, err.err_msg);
        goto cci_work_end;
    }

    error = cci_fetch (req, &err);
    if (error < 0)
    {
        printf ("fetch error: %d, %s\n", err.err_code, err.err_msg);
        goto cci_work_end;
    }

    error = cci_get_data (req, 1, CCI_A_TYPE_INT, &data, &ind);
    if (error < 0)
    {
        printf ("get data error: %d\n", error);
        goto cci_work_end;
    }
        printf ("%d\n", data);
    }
    error = 1;

cci_work_end:
    cci_close_req_handle (req);
    return error;
}

Configuring Library¶

Once you have written applications using CCI, you should decide, according to its features, whether to execute CCI as static or dynamic link before you build it. See the table in CCI Overview to decide which library will be used.

The following is an example of Makefile, which makes a link by using the dynamic library on UNIX/Linux.

CC=gcc
CFLAGS = -g -Wall -I. -I$CUBRID/include
LDFLAGS = -L$CUBRID/lib -lcascci -lnsl
TEST_OBJS = test.o
EXES = test
all: $(EXES)
test: $(TEST_OBJS)
    $(CC) -o $@ $(TEST_OBJS) $(LDFLAGS)

The following image shows configuration to use static library on Windows.

int con = 0; /* connection handle */
int req = 0; /* request handle */
int res;
int n_executed;
int i;
T_CCI_ERROR error;
T_CCI_BLOB blob = NULL;
char data[1024] = "bulabula";

con = cci_connect ("localhost", 33000, "tdb", "PUBLIC", "");
if (con < 0) {
    goto handle_error;
}
req = cci_prepare (con, "insert into doc (doc_id, content) values (?,?)", 0, &error);
if (req< 0)
{
    goto handle_error;
}

res = cci_bind_param (req, 1 /* binding index*/, CCI_A_TYPE_STR, "doc-10", CCI_U_TYPE_STRING, CCI_BIND_PTR);

/* Creating an empty LOB data file */
res = cci_blob_new (con, &blob, &error);
res = cci_blob_write (con, blob, 0 /* start position */, 1024 /* length */, data, &error);

/* Binding BLOB data */
res = cci_bind_param (req, 2 /* binding index*/, CCI_A_TYPE_BLOB, (void *)blob, CCI_U_TYPE_BLOB, CCI_BIND_PTR);

n_executed = cci_execute (req, 0, 0, &error);
if (n_executed < 0)
{
    goto handle_error;
}

/* Commit */
if (cci_end_tran(con, CCI_TRAN_COMMIT, &error) < 0)
{
    goto handle_error;
}

/* Memory free */
cci_blob_free(blob);
return 0;

handle_error:
if (blob != NULL)
{
    cci_blob_free(blob);
}
if (req > 0)
{
    cci_close_req_handle (req);
}
if (con > 0)
{
    cci_disconnect(con, &error);
}
return -1;

int con = 0; /* connection handle */
int req = 0; /* request handle */
int ind; /* NULL indicator, 0 if not NULL, -1 if NULL*/
int res;
int i;
T_CCI_ERROR error;
T_CCI_BLOB blob;
char buffer[1024];

con = cci_connect ("localhost", 33000, "image_db", "PUBLIC", "");
if (con < 0)
{
    goto handle_error;
}
req = cci_prepare (con, "select content from doc_t", 0 /*flag*/, &error);
if (req< 0)
{
    goto handle_error;
}

res = cci_execute (req, 0/*flag*/, 0/*max_col_size*/, &error);
res = cci_fetch_size (req, 100 /* fetch size */);

while (1) {
    res = cci_cursor (req, 1/* offset */, CCI_CURSOR_CURRENT/* cursor position */, &error);
    if (res == CCI_ER_NO_MORE_DATA)
    {
        break;
    }
    res = cci_fetch (req, &error);

    /* Fetching CLOB Locator */
    res = cci_get_data (req, 1 /* colume index */, CCI_A_TYPE_BLOB,
    (void *)&blob /* BLOB handle */, &ind /* NULL indicator */);
    /* Fetching CLOB data */
    res = cci_blob_read (con, blob, 0 /* start position */, 1024 /* length */, buffer, &error);
    printf ("content = %s\n", buffer);
}

/* Memory free */
cci_blob_free(blob);
res=cci_close_req_handle(req);
res = cci_disconnect (con, &error);
return 0;

handle_error:
if (req > 0)
{
    cci_close_req_handle (req);
}
if (con > 0)
{
    cci_disconnect(con, &error);
}
return -1;

// gcc -o err err.c -m64 -I${CUBRID}/include -lnsl ${CUBRID}/lib/libcascci.so -lpthread
#include <stdio.h>
#include "cas_cci.h"

#define BUFSIZE  (1024)

int
main (void)
{
    int con = 0, req = 0, col_count = 0, i, ind;
    int error;
    char *data;
    T_CCI_ERROR err_buf;
    char *query = "select * from notable";

    //getting a connection handle for a connection with a server
    con = cci_connect ("localhost", 33000, "demodb", "dba", "");
    if (con < 0)
    {
        printf ("cannot connect to database\n");
        return 1;
    }

    //preparing the SQL statement
    req = cci_prepare (con, query, 0, & err_buf);
    if (req < 0)
    {
        if (req == CCI_ER_DBMS)
        {
            printf ("error from server: %d, %s\n", err_buf.err_code, err_buf.err_msg);
        }
        else
        {
            char msg_buf[1024];
            cci_get_err_msg(req, msg_buf, 1024);
            printf ("error from cas: %d, %s\n", req, msg_buf);
        }
        goto handle_error;
    }
    // ...
}

CCI Sample Program¶

The sample program shows how to write a CCI application by using the demodb database which is included with the CUBRID installation package. You can practice the ways to connect to CAS, prepare queries, execute queries, handle response, disconnect from CAS, etc. by following sample program below. In the sample program, the dynamic link on Linux environment is used.

The code below shows information about olympic table schema in the demodb database which is used for sample program.

csql> ;sc olympic

=== <Help: Schema of a Class> ===


 <Class Name>

     olympic

 <Attributes>

     host_year            INTEGER NOT NULL
     host_nation          CHARACTER VARYING(40) NOT NULL
     host_city            CHARACTER VARYING(20) NOT NULL
     opening_date         DATE NOT NULL
     closing_date         DATE NOT NULL
     mascot               CHARACTER VARYING(20)
     slogan               CHARACTER VARYING(40)
     introduction         CHARACTER VARYING(1500)

 <Constraints>

     PRIMARY KEY pk_olympic_host_year ON olympic (host_year)

Preparing

Make sure that the demodb database and the broker are running before you execute the sample program. You can start the demodb database and the broker by executing the cubrid utility. The code below shows how to run a database server and broker by executing the cubrid utility.

[tester@testdb ~]$ cubrid server start demodb
@ cubrid master start
++ cubrid master start: success
@ cubrid server start: demodb

This may take a long time depending on the amount of recovery works to do.

CUBRID 9.0

++ cubrid server start: success
[tester@testdb ~]$ cubrid broker start
@ cubrid broker start
++ cubrid broker start: success

Building

With the program source and the Makefile prepared, executing make will create an executable file named test. If you use a static library, there is no need to deploy additional files and the execution will be faster. However, it increases the program size and memory usage. If you use a dynamic library, there will be some performance overhead but the program size and memory usage can be optimized.

The code below a command line that makes a test program build by using a dynamic library instead of using make on Linux.

cc -o test test.c -I$CUBRID/include -L$CUBRID/lib -lnsl -lcascci

Sample Code

#include <stdio.h>
#include <cas_cci.h>
char *cci_client_name = "test";
int main (int argc, char *argv[])
{
    int con = 0, req = 0, col_count = 0, res, ind, i;
    T_CCI_ERROR error;
    T_CCI_COL_INFO *res_col_info;
    T_CCI_CUBRID_STMT stmt_type;
    char *buffer, db_ver[16];
    printf("Program started!\n");
    if ((con=cci_connect("localhost", 30000, "demodb", "PUBLIC", ""))<0) {
        printf( "%s(%d): cci_connect fail\n", __FILE__, __LINE__);
        return -1;
    }

    if ((res=cci_get_db_version(con, db_ver, sizeof(db_ver)))<0) {
        printf( "%s(%d): cci_get_db_version fail\n", __FILE__, __LINE__);
        goto handle_error;
    }
    printf("DB Version is %s\n",db_ver);
    if ((req=cci_prepare(con, "select * from event", 0,&error))<0) {
        if (req == CCI_ER_DBMS) {
            printf( "%s(%d): cci_prepare fail(%d)\n", __FILE__, __LINE__,error.err_code);
        }
        else {
            char msg_buf[1024];
            cci_get_err_msg(req, msg_buf, 1024);
            printf ("error from cas: %d, %s\n", req, msg_buf);
        }
        goto handle_error;
    }
    printf("Prepare ok!(%d)\n",req);
    res_col_info = cci_get_result_info(req, &stmt_type, &col_count);
    if (!res_col_info) {
        printf( "%s(%d): cci_get_result_info fail\n", __FILE__, __LINE__);
        goto handle_error;
    }

    printf("Result column information\n"
           "========================================\n");
    for (i=1; i<=col_count; i++) {
        printf("name:%s  type:%d(precision:%d scale:%d)\n",
            CCI_GET_RESULT_INFO_NAME(res_col_info, i),
            CCI_GET_RESULT_INFO_TYPE(res_col_info, i),
            CCI_GET_RESULT_INFO_PRECISION(res_col_info, i),
            CCI_GET_RESULT_INFO_SCALE(res_col_info, i));
    }
    printf("========================================\n");
    if ((res=cci_execute(req, 0, 0, &error))<0) {
        if (req == CCI_ER_DBMS) {
            printf( "%s(%d): cci_execute fail(%d)\n", __FILE__, __LINE__,error.err_code);
        }
        else {
            char msg_buf[1024];
            cci_get_err_msg(req, msg_buf, 1024);
            printf ("error from cas: %d, %s\n", req, msg_buf);
        }
        goto handle_error;
    }
    if ((res=cci_fetch_size(req, 100))<0) {
        printf( "%s(%d): cci_fetch_size fail\n", __FILE__, __LINE__);
        goto handle_error;
    }

    while (1) {
        res = cci_cursor(req, 1, CCI_CURSOR_CURRENT, &error);
        if (res == CCI_ER_NO_MORE_DATA) {
            printf("Query END!\n");
            break;
        }
        if (res<0) {
            if (req == CCI_ER_DBMS) {
                printf( "%s(%d): cci_cursor fail(%d)\n", __FILE__, __LINE__,error.err_code);
            }
            else {
                char msg_buf[1024];
                cci_get_err_msg(req, msg_buf, 1024);
                printf ("error from cas: %d, %s\n", req, msg_buf);
            }
            goto handle_error;
        }

        if ((res=cci_fetch(req, &error))<0) {
            if (res == CCI_ER_DBMS) {
                printf( "%s(%d): cci_fetch fail(%d)\n", __FILE__, __LINE__,error.err_code);
            }
            else {
                char msg_buf[1024];
                cci_get_err_msg(req, msg_buf, 1024);
                printf ("error from cas: %d, %s\n", req, msg_buf);
            }
            goto handle_error;
        }

        for (i=1; i<=col_count; i++) {
            if ((res=cci_get_data(req, i, CCI_A_TYPE_STR, &buffer, &ind))<0) {
                printf( "%s(%d): cci_get_data fail\n", __FILE__, __LINE__);
                goto handle_error;
            }
            printf("%s \t|", buffer);
        }
        printf("\n");
    }
    if ((res=cci_close_req_handle(req))<0) {
        printf( "%s(%d): cci_close_req_handle fail", __FILE__, __LINE__);
       goto handle_error;
    }
    if ((res=cci_disconnect(con, &error))<0) {
        if (res == CCI_ER_DBMS) {
            printf( "%s(%d): cci_disconnect fail(%d)", __FILE__, __LINE__,error.err_code);
        }
        else {
            char msg_buf[1024];
            cci_get_err_msg(req, msg_buf, 1024);
            printf ("error from cas: %d, %s\n", req, msg_buf);
        }
        goto handle_error;
    }
    printf("Program ended!\n");
    return 0;

    handle_error:
    if (req > 0)
        cci_close_req_handle(req);
    if (con > 0)
        cci_disconnect(con, &error);
    printf("Program failed!\n");
    return -1;
}

CCI API Reference¶

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)¶

The cci_bind_param function binds data in the bind variable of prepared statement. This function converts value of the given a_type to an actual binding type and stores it. Subsequently, whenever cci_execute() is called, the stored data is sent to the server. If cci_bind_param () is called multiple times for the same index, the latest configured value is valid.

Parameters:	req_handle -- (IN) Request handle of a prepared statement index -- (IN) Location of binding; it starts with 1. a_type -- (IN) Data type of value value -- (IN) Data value to bind u_type -- (IN) Data type to be applied to the database flag -- (IN) bind_flag(CCI_BIND_PTR).
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_TYPE_CONVERSION CCI_ER_BIND_INDEX CCI_ER_ATYPE CCI_ER_NO_MORE_MEMORY

If NULL is bound to the database, there can be two scenarios.

• When the value of value is a NULL pointer
• When the value of u_type is CCI_U_TYPE_NULL

If CCI_BIND_PTR is configured for flag, the pointer of value variable is copied (shallow copy), but no value is copied. If it is not configured for flag, the value of value variable is copied (deep copy) by allocating memory. If multiple columns are bound by using the same memory buffer, CCI_BIND_PTR must not be configured for the flag.

T_CCI_A_TYPE is a C language type that is used in CCI applications for data binding, and consists of primitive types such as int and float, and user-defined types defined by CCI such as T_CCI_BIT and T_CCI_DATE. The identifier for each type is defined as shown in the table below.

a_type	value type
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

T_CCI_U_TYPE is a column type of database and data bound though the value argument is converted into this type. The cci_bind_param () function uses two kinds of types to send information which is used to convert U-type data from A-type data; the U-type data can be interpreted by database language and the A-type data can be interpreted by C language.

There are various A-type data that are allowed by U-type data. For example, CCI_U_TYPE_INT can receive CCI_A_TYPE_STR as A-type data including CCI_A_TYPE_INT. For information on type conversion, see "CUBRID SQL Guide > Data Types > Implicit Type Conversion > Rules."

Both T_CCI_A_TYPE and T_CCI_U_TYPE enum(s) are defined in the cas_cci.h file. The definition of each identifier is described in the table below.

u_type	Corresponding a_type (default)
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_MONETARY	CCI_A_TYPE_DOUBLE
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

When the string including the date is used as an input parameter of DATE, DATETIME, or TIMESTAMP, only "YYYY/MM/DD" is allowed for the date string type. Therefore, "2012/01/31" is valid, but "01/31/2012" or "2012-01-31" is invalid. The following is an example of having the string that includes the date as an input parameter of the date type.

// "CREATE TABLE tbl(aa date, bb datetime)";

char *values[][3] =
{
    {"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)NULL);
    res = cci_bind_param(req, 2, CCI_A_TYPE_STR, values[i][1], CCI_U_TYPE_DATETIME, (char)NULL);
    cci_execute(req, CCI_EXEC_QUERY_ALL, 0, err_buf);
}

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)¶

The cci_bind_param_array function binds a parameter array for a prepared cci_execute_array() occurs, data is sent to the server by the stored value pointer. If cci_bind_param_array () is called multiple times for the same index, the last configured value is valid. If NULL is bound to the data, a non-zero value is configured in null_ind. If value is a NULL pointer, or u_type is CCI_U_TYPE_NULL, all data are bound to NULL and the data buffer used by value cannot be reused. For the data type of value for a_type, see the cci_bind_param() function description.

Parameters:	req_handle -- (IN) Request handle of the prepared statement index -- (IN) Binding location a_type -- (IN) Data type of value value -- (IN) Data value to be bound null_ind -- (IN) NULL indicator array (0 : not NULL, 1 : NULL) u_type -- (IN) Data type to be applied to the database.
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_TYPE_CONVERSION CCI_ER_BIND_INDEX CCI_ER_ATYPE CCI_ER_BIND_ARRAY_SIZE

int cci_bind_param_array_size(int req_handle, int array_size)¶

The cci_bind_param_array_size function determines the size of the array to be used in cci_bind_param_array(). cci_bind_param_array_size () must be called first before cci_bind_param_array() is used.

Parameters:	req_handle -- Request handle of a prepared statement array_size -- (IN) binding array size
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE

int cci_blob_free(T_CCI_BLOB blob)¶

The cci_blob_free function frees memory of blob struct.

Returns:	Error code (0: success) CCI_ER_INVALID_LOB_HANDLE

int cci_blob_new(int conn_handle, T_CCI_BLOB* blob, T_CCI_ERROR* error_buf)¶

The cci_blob_new function creates an empty file where LOB data is stored and returns Locator referring to the data to blob struct.

Parameters:	conn_handle -- (IN) Connection handle blob -- (OUT) LOB Locator error_buf -- (OUT) Error buffer
Returns:	Error code (0: success) CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

int cci_blob_read(int conn_handle, T_CCI_BLOB blob, long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf)¶

The cci_blob_read function reads as much as data from start_pos to length of the LOB data file specified in blob; then it stores it in buf and returns it.

Parameters:	conn_handle -- (IN) Connection handle blob -- (OUT) LOB Locator start_pos -- (IN) Index location of LOB data file length -- (IN) LOB data length from buffer error_buf -- (OUT) Error buffer
Returns:	Size of read value (>= 0: success), Error code (< 0: error) CCI_ER_INVALID_LOB_READ_POS CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

long long cci_blob_size(T_CCI_BLOB* blob)¶

The cci_blob_size function returns data file size that is specified in blob.

Parameters:	blob -- (OUT) LOB Locator
Returns:	Size of BLOB data file (>= 0: success), Error code (< 0: error) CCI_ER_INVALID_LOB_HANDLE

int cci_blob_write(int conn_handle, T_CCI_BLOB blob, long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf)¶

The cci_blob_write function reads as much as data from buf to length and stores it from start_pos of the LOB data file specified in blob.

Parameters:	conn_handle -- (IN) Connection handle blob -- (OUT) LOB Locator start_pos -- (IN) Index location of LOB data file length -- (IN) Data length from buffer error_buf -- (OUT) Error buffer
Returns:	Size of written value (>= 0: success), Error code (< 0: error) CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

int cci_cancel(int conn_handle)¶

Cancel the running query on the other thread. This function executes the same behavior as Statement.cancel() method in JAVA.

The following shows how to cancel the query execution of a thread.

/* gcc -o pthr pthr.c -m64 -I${CUBRID}/include -lnsl ${CUBRID}/lib/libcascci.so -lpthread
*/


#include <stdio.h>
#include <cas_cci.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <time.h>

#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)
    {
        if ((res = cci_fetch_size (req, 100)) < 0)
        {
            snprintf (error_msg, 128, "cci_fetch_size ERROR\n");
            goto execute_error;
        }

        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)) < 0)
    {
        snprintf (error_msg, 128, "cci_close_query_result ERROR\n");
        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;
}

Parameters:	conn_handle -- (IN) Connection handle
Returns:	Error code CCI_ER_CON_HANDLE

int cci_clob_free(T_CCI_CLOB clob)¶

The cci_clob_free function frees memory of CLOB struct.

Parameters:	clob -- (IN) LOB Locator
Returns:	Error code (0: success) CCI_ER_INVALID_LOB_HANDLE

int cci_clob_new(int conn_handle, T_CCI_CLOB* clob, T_CCI_ERROR* error_buf)¶

The cci_clob_new  function creates an empty file where LOB data is stored and returns Locator referring to the data to clob struct.

Parameters:	conn_handle -- ((IN) Connection handle clob -- (OUT) LOB Locator error_buf -- (OUT) Error buffer
Returns:	Error code (0: success) CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

int cci_clob_read(int conn_handle, T_CCI_CLOB clob, long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf)¶

The cci_clob_read  function reads as much as data from start_pos to length in the LOB data file specified in clob; then it stores it in buf and returns it.

Parameters:	conn_handle -- (IN) Connection handle clob -- (IN) LOB Locator start_pos -- (IN) Index location of LOB data file length -- (IN) LOB data length from buffer error_buf -- (OUT) Error buffer
Returns:	Size of read value (>= 0: success), Error code (< 0: Error) CCI_ER_INVALID_LOB_READ_POS CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

long long cci_clob_size(T_CCI_CLOB* clob)¶

The cci_clob_size function returns data file size that is specified in clob.

Parameters:	clob -- (IN) LOB Locator
Returns:	Size of CLOB data file (>= 0: success), Error code (< 0: error) CCI_ER_INVALID_LOB_HANDLE

int cci_clob_write(int conn_handle, T_CCI_CLOB clob, long start_pos, int length, const char *buf, T_CCI_ERROR* error_buf)¶

The cci_clob_write  function reads as much as data from buf to length and then stores the value from start_pos in LOB data file specified in clob.

Parameters:	conn_handle -- (IN) Connection handle clob -- (IN) LOB Locator start_pos -- (IN) Index location of LOB data file length -- (IN) Data length from buffer error_buf -- (OUT) Error buffer
Returns:	Size of written value (>= 0: success), Error code (< 0: Error) CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_DBMS CCI_ER_INVALID_LOB_HANDLE

int cci_close_query_result(int req_handle)¶

The cci_close_query_result funciton closes the resultset returned by cci_execute(), cci_execute_array() or cci_execute_batch(). If you run cci_prepare() repeatedly without closing the request handle(req_handle), it is recommended to call this function before calling cci_close_req_handle().

Parameters:	req_handle -- (IN) Request handle
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_COMMUNICATION

int cci_close_req_handle(int req_handle)¶

The cci_close_req_handle function closes the request handle obtained by cci_prepare().

Parameters:	req_handle -- (IN) Request handle
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_COMMUNICATION

int cci_col_get(int conn_handle, char *oid_str, char *col_attr, int *col_size, int *col_type, T_CCI_ERROR *err_buf)¶

The cci_col_get function gets an attribute value of collection type. If the name of the class is C, and the domain of set_attr is set (multiset, sequence), the query looks like as follows:

SELECT a FROM C, TABLE(set_attr) AS t(a) WHERE C = oid;

That is, the number of members becomes the number of records.

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) Collection attribute name col_size -- (OUT) Collection size (-1 : null) col_type -- (OUT) Collection type (set, multiset, sequence: u_type) err_buf -- (OUT) Database error buffer
Returns:	Request handle CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_col_seq_drop(int conn_handle, char *oid_str, char *col_attr, int index, T_CCI_ERROR *err_buf)¶

The cci_col_seq_drop function drops the index-th (base: 1) member of the sequence attribute values. The following example shows how to drop the first member of the sequence attribute values.

cci_col_seq_drop(conn_handle, oid_str, seq_attr, 1, err_buf);

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) Collection attribute name index -- (IN) Index err_buf -- (OUT) Database error buffer
Returns:	Error code CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_col_seq_insert(int conn_handle, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR *err_buf)¶

The cci_col_seq_insert function inserts one member at the index-th (base: 1) position of the sequence attribute values. The following example shows how to insert "a" at the first position of the sequence attribute values.

cci_col_seq_insert(conn_handle, oid_str, seq_attr, 1, "a", err_buf);

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) Collection attribute name index -- (IN) Index value -- (IN) Sequential element (string) err_buf -- (OUT) Database error buffer
Returns:	Error code CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_col_seq_put(int conn_handle, char *oid_str, char *col_attr, int index, char *value, T_CCI_ERROR *err_buf)¶

The cci_col_seq_put function replaces the index-th (base: 1) member of the sequence attribute values with a new value. The following example shows how to replace the first member of the sequence attributes values with "a".

cci_col_seq_put(conn_handle, oid_str, seq_attr, 1, "a", err_buf);

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) Collection attribute name index -- (IN) Index value -- (IN) Sequential value err_buf -- (OUT) Database error buffer
Returns:	Error code CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_col_set_add(int conn_handle, char *oid_str, char *col_attr, char *value, T_CCI_ERRROR *err_buf)¶

The cci_col_set_add function adds one member to the set attribute values. The following example shows how to add "a" to the set attribute values.

cci_col_set_add(conn_handle, oid_str, set_attr, "a", err_buf);

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) collection attribute name value -- (IN) set element err_buf -- (OUT) Database error buffer
Returns:	Error code CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_col_set_drop(int conn_handle, char *oid_str, char *col_attr, char *value, T_CCI_ERROR *err_buf)¶

The cci_col_set_drop function drops one member from the set attribute values. The following example shows how to drop "a" from the set attribute values.

cci_col_set_drop(conn_handle, oid_str, set_attr, "a", err_buf);

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) collection attribute name value -- (IN) set element (string) err_buf -- (OUT) Database error buffer
Returns:	Error code CCI_ER_CON_HANDLE CCI_ER_QUERY_TIMEOUT CCI_ER_LOGIN_TIMEOUT CCI_ER_COMMUNICATION

int cci_col_size(int conn_handle, char *oid_str, char *col_attr, int *col_size, T_CCI_ERROR *err_buf)¶

The cci_col_size function gets the size of the set (seq) attribute.

Parameters:	conn_handle -- (IN) Connection handle oid_str -- (IN) oid col_attr -- (IN) Collection attribute name col_size -- (OUT) Collection size (-1: NULL) err_buf -- Database error buffer
Returns:	Error code (0: success) CCI_ER_CON_HANDLE CCI_ER_CONNECT CCI_ER_OBJECT CCI_ER_DBMS

int cci_connect(char *ip, int port, char *db_name, char *db_user, char *db_password)¶

A connection handle to the database server is assigned and it tries to connect to the server. If it has succeeded, the connection handle ID is returned; if fails, an error code is returned.

Parameters:	ip -- (IN) A string that represents the IP address of the server (host name) port -- (IN) Broker port (The port configured in the $CUBRID/conf/cubrid_broker.conf file) db_name -- (IN) Database name db_user -- (IN) Database user name db_passwd -- (IN) Database user password
Returns:	Success: Connection handle ID (int), Failure: Error code CCI_ER_NO_MORE_MEMORY CCI_ER_HOSTNAME CCI_ER_CON_HANDLE CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_CONNECT

int cci_connect_ex(char *ip, int port, char *db_name, char *db_user, char *db_password, T_CCI_ERROR * err_buf)¶

The cci_connect_ex function returns CCI_ER_DBMS error and checks the error details in the database error buffer (err_buf) at the same time. In that point, it is different from cci_connect() and the others are the same as the cci_connect() function.

Parameters:	ip -- (IN) A string that represents the IP address of the server (host name) port -- (IN) Broker port (The port configured in the $CUBRID/conf/cubrid_broker.conf file) db_name -- (IN) Database name db_user -- (IN) Database user name db_passwd -- (IN) Database user password err_buf -- Database error buffer
Returns:	Success: Connection handle ID (int), Failure: Error code CCI_ER_NO_MORE_MEMORY CCI_ER_HOSTNAME CCI_ER_CON_HANDLE CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_CONNECT

int cci_connect_with_url(char *url, char *db_user, char *db_password)¶

The cci_connect_with_url function connects a database by using connection information passed with a url argument. If broker's HA feature is used in CCI, you must specify the connection information of the standby broker server with altHosts property, which is used for the failover, in the url argument of this function. It returns the ID of a connection handle on success; it returns an error code on failure. For details about HA features of broker, see Duplexing Brokers.

Parameters:

url -- (IN) A string that contains server connection information. db_user -- (IN) Database user name. If it is NULL or an empty string, it becomes <db_user> in url. If both of this value and <db_user> in url are not specified, DB user name becomes PUBLIC. db_passwd -- (IN) Database user password. If it is NULL or an empty string, use <db_password> in url. If both of this value and <db_password> in url are not specified, DB password becomes NULL.

Returns:

Success: Connection handle ID (int), Failure: Error code 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

<url> ::= cci:CUBRID:<host>:<port>:<db_name>:<db_user>:<db_password>:[?<properties>]

<properties> ::= <property> [&<property>]
<property> ::= altHosts=<alternative_hosts> [ &rcTime=<time>] [ &loadBalance=true|false]
             |{login_timeout|loginTimeout}=<milli_sec>
             |{query_timeout|queryTimeout}=<milli_sec>
             |{disconnect_on_query_timeout|disconnectOnQueryTimeout}=true|false
             | logFile=<file_name>
             | logBaseDir=<dir_name>
             | logSlowQueries=true|false[&slowQueryThresholdMillis=<milli_sec>]
             | logTraceApi=true|false
             | logTraceNetwork=true|false

<alternative_hosts> ::= <host>:<port> [,<host>:<port>]

<host> := HOSTNAME | IP_ADDR
<time> := SECOND
<milli_sec> := MILLI SECOND

altHosts is the property related to connection target and loginTimeout, queryTimeout, and disconnectOnQueryTimeout are the properties related to timeout; logSlowQueries, logTraceApi, and logTraceNetwork are the properties related to log information configuration for debugging.

Note that a property name which is a value to be entered in the url argument is not case sensitive.

• host : A host name or IP address of the master database
• port : A port number
• db_name : A name of the database
• db_user : A name of the database user
• db_password : A database user password
• altHosts = standby_broker1_host, standby_broker2_host, . . .: Specifies the broker information of the standby server, which is used for failover when it is impossible to connect to the active server. You can specify multiple brokers for failover, and the connection to the brokers is attempted in the order listed in alhosts.
• rcTime : After the failure occurred on the first connected broker, the application connects to the broker specified by altHosts(broker failover). Then it attempts to reconnect to the first connected broker at every rcTime(default value: 600 seconds).
• loadBalance : When this value is true, the applications try to connect to the main host and alternative hosts specified with the altHosts property as a random order. (default value: false).
• login_timeout | loginTimeout : Timeout value (unit: msec.) for database login. Upon timeout, a CCI_ER_LOGIN_TIMEOUT (-38) error is returned. The default value is 0, which means infinite postponement.
• query_timeout | queryTimeout : If time specified in these properties has expired when calling cci_prepare(), cci_execute(), etc. a cancellation message for query request which was sent to a server will be delivered and called function returns a CCI_ER_QUERY_TIMEOUT (-39) error. The value returned upon timeout may vary depending on a value specified in disconnect_on_query_timeout. For details, see disconnect_on_query_timeout.
• disconnect_on_query_timeout | disconnectOnQueryTimeout : Whether to disconnect socket immediately after time for query request has expired. It determines whether to terminate a socket connection immediately or wait for server response after sending cancellation message for query request to a server when calling cci_prepare(), cci_execute(), etc. The default value is false, meaning that it will wait for server response. It this value is true, a socket will be closed immediately after sending a cancellation message to a server upon timeout and returns the CCI_ER_QUERY_TIMEOUT (-39) error. (If an error occurs on database server side, not on broker side, it returns -1. If you want to view error details, see error codes in "database error buffer." You can get information how to check error codes in CCI Error Codes and Error Messages.) In this case, you must explicitly close the database connection handle by using the cci_disconnect() function. Please note that there is a possibility that a database server does not get a cancellation message and execute a query even after an error is returned.
• logFile : A log file name for debugging (default value: cci_ <handle_id> .log). <handle_id> indicates the ID of a connection handle returned by this function.
• logBaseDir : A directory where a debug log file is created. The file name including the path will be logBaseDir/logFile, and the relative path is possible.
• logSlowQueries : Whether to log slow query for debugging (default value: false)
• slowQueryThresholdMillis : Timeout for slow query logging if slow query logging is enabled (default value: 60000, unit: milliseconds)
• logTraceApi : Whether to log the start and end of CCI functions
• logTraceNetwork : Whether to log network data content transferred of CCI functions

Example

--connection URL string when a property(altHosts) is specified for HA
URL=cci:CUBRID:192.168.0.1:33000:demodb:::?altHosts=192.168.0.2:33000,192.168.0.3:33000

--connection URL string when properties(altHosts,rcTime) is specified for HA
URL=cci:CUBRID:192.168.0.1:33000:demodb:::?altHosts=192.168.0.2:33000,192.168.0.3:33000&rcTime=600

--connection URL string when properties(logSlowQueries,slowQueryThresholdMills, logTraceApi, logTraceNetwork) are specified for interface debugging
URL = "cci:cubrid:192.168.0.1:33000:demodb:::?logSlowQueries=true&slowQueryThresholdMillis=1000&logTraceApi=true&logTraceNetwork=true"

int cci_connect_with_url_ex(char *url, char *db_user, char *db_password, T_CCI_ERROR * err_buf)¶

The cci_connect_with_url_ex function returns CCI_ER_DBMS error and checks the error details in the database error buffer (err_buf) at the same time. In that point, it is different from cci_connect_with_url() and the others are the same as the cci_connect_with_url() function.

Parameters:	url -- (IN) A string that contains server connection information db_user -- (IN) Database user name. If it is NULL or an empty string, use <db_user> in url. db_passwd -- (IN) Database user password. If it is NULL or an empty string, use <db_password> in url. err_buf -- Database error buffer
Returns:	Success: Connection handle ID (int), Failure: Error code 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

int cci_cursor(int req_handle, int offset, T_CCI_CURSOR_POS origin, T_CCI_ERROR *err_buf)¶

The cci_cursor function moves the cursor specified in the request handle to access the specific record in the query result executed by cci_execute(). The position of cursor is moved by the values specified in the origin and offset values. If the position to be moved is not valid, CCI_ER_NO_MORE_DATA is returned.

Parameters:	req_handle -- (IN) Request handle offset -- (IN) Offset to be moved origin -- (IN) Variable to represent a position. The type is T_CCI_CURSOR_POS. T_CCI_CURSOR_POS enum consists of CCI_CURSOR_FIRST, CCI_CURSOR_CURRENT and CCI_CURSOR_LAST. err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_NO_MORE_DATA CCI_ER_COMMUNICATION

Example

//the cursor moves to the first record
cci_cursor(req, 1, CCI_CURSOR_FIRST, &err_buf);

//the cursor moves to the next record
cci_cursor(req, 1, CCI_CURSOR_CURRENT, &err_buf);

//the cursor moves to the last record
cci_cursor(req, 1, CCI_CURSOR_LAST, &err_buf);

//the cursor moves to the previous record
cci_cursor(req, -1, CCI_CURSOR_CURRENT, &err_buf);

int cci_cursor_update(int req_handle, int cursor_pos, int index, T_CCI_A_TYPE a_type, void *value, T_CCI_ERROR *err_buf)¶

The cci_cursor_update function updates cursor_pos from the value of the index -th column to value. If the database is updated to NULL, value becomes NULL. For update conditions, see cci_prepare(). The data types of value for a_type are shown in the table below.

Parameters:	req_handle -- (IN) Request handle cursor_pos -- (IN) Cursor position index -- (IN) Column index a_type -- (IN) value Type value -- (IN) A new value err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_TYPE_CONVERSION CCI_ER_ATYPE

a_type	value type
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

T_CCI_CONN cci_datasource_borrow(T_CCI_DATASOURCE * datasource, T_CCI_ERROR * err_buf)¶

The cci_datasource_borrow function obtains CCI connection to be used in T_CCI_DATASOURCE struct.

Parameters:	datasource -- (IN) T_CCI_DATASOURCE struct pointer in which CCI connection exists err_buf -- (OUT) Error code and message returned upon error occurrence
Returns:	Success: CCI connection handler identifier, Failure: -1

See also

cci_property_create(), cci_property_destroy(), cci_property_get(), cci_property_set(), cci_datasource_create(), cci_datasource_destroy(), cci_datasource_release()

T_CCI_DATASOURCE * cci_datasource_create(T_CCI_PROPERTIES * properties, T_CCI_ERROR * err_buf)¶

The cci_datasource_create function creates DATASOURCE of CCI.

Parameters:	properties -- (IN) T_CCI_PROPERTIES struct pointer in which configuration of struct pointer is stored. Values of properties will be set with cci_property_set(). err_buf -- (OUT) Error code and message returned upon error occurrence
Returns:	Success: T_CCI_DATASOURCE struct pointer created, Failure: NULL

See also

cci_property_create(), cci_property_destroy(), cci_property_get(), cci_property_set(), cci_datasource_create(), cci_datasource_destroy(), cci_datasource_release()

void cci_datasource_destroy(T_CCI_DATASOURCE * datasource)¶

The cci_datasource_destroy function destroys DATASOURCE of CCI.

Parameters:	datasource -- (IN) T_CCI_DATASOURCE struct pointer to be deleted
Returns:	void

See also

cci_property_create(), cci_property_destroy(), cci_property_get(), cci_property_set(), cci_datasource_create(), cci_datasource_destroy(), cci_datasource_release()

int cci_datasource_release(T_CCI_DATASOURCE * datasource, T_CCI_CONN conn)¶

The cci_datasource_release function returns CCI connection released in T_CCI_DATASOURCE struct. If you want to reuse the connection after calling this function, recall c:func:cci_datasource_borrow.

Parameters:	datasource -- (IN) T_CCI_DATASOURCE struct pointer which returns CCI connection conn -- (IN) CCI connection handler identifier released
Returns:	Success: 1, Failure: 0

See also

cci_property_create(), cci_property_destroy(), cci_property_get(), cci_property_set(), cci_datasource_create(), cci_datasource_destroy(), cci_datasource_release()

int cci_disconnect(int conn_handle, T_CCI_ERROR * err_buf)¶

The cci_disconnect function disconnects all request handles created for conn_handle. If a transaction is being performed, the handles are disconnected after cci_end_tran() is executed.

Parameters:	conn_handle -- (IN) Connection handle err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_CON_HANDLE CCI_ER_DBMS CCI_ER_COMMUNICATION

int cci_end_tran(int conn_handle, char type, T_CCI_ERROR *err_buf)¶

The cci_end_tran function performs commit or rollback on the current transaction. At this point, all open request handles are terminated and the connection to the database server is disabled. However, even after the connection to the server is disabled, the connection handle remains valid.

Parameters:	conn_handle -- (IN) Connection handle type -- (IN) CCI_TRAN_COMMIT or CCI_TRAN_ROLLBACK err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_CON_HANDLE CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_TRAN_TYPE

You can configure the default value of auto-commit mode by using CCI_DEFAULT_AUTOCOMMIT (broker parameter) upon startup of an application. If configuration on broker parameter is omitted, the default value is ON; use the cci_set_autocommit() function to change auto-commit mode within an application. If auto-commit mode is OFF, you must explicitly commit or roll back transaction by using the cci_end_tran() function.

long cci_escape_string(int conn_handle, char *to, const char *from, unsigned long length, T_CCI_ERROR *err_buf)¶

Converts the input string to a string that can be used in the CUBRID query. The following parameters are specified in this function: connection handle or no_backslash_escapes setting value, output string pointer, input string pointer, the length of the input string, and the address of the T_CCI_ERROR struct variable.

Parameters:

conn_handle -- (IN) connection handle or no_backslash_escapes setting value. When a connection handle is given, the no_backslash_escapes parameter value is read to determine how to convert. Instead of the connection handle, CCI_NO_BACKSLASH_ESCAPES_TRUE or CCI_NO_BACKSLASH_ESCAPES_FALSE value can be sent to determine how to convert. to -- (OUT) Result string from -- (IN) Input string length -- (IN) Maximum byte length of the input string err_buf -- (OUT) Database error buffer

Returns:

Success: Byte length of the changed string, Failure: Error Code CCI_ER_CON_HANDLE CCI_ER_COMMUNICATION

When the system parameter no_backslash_escapes is yes (default) or when the CCI_NO_BACKSLASH_ESCAPES_TRUE value is sent to the connection handle location, the string is converted to the following characters.

• ' (single quote) => ' + ' (escaped single quote)

When the system parameter no_backslash_escapes is no or when the CCI_NO_BACKSLASH_ESCAPES_FALSE value is sent to the connection handle location, the string is converted to the following characters:

• \n (new line character, ASCII 10) => \ + n (backslash + Alphabet n)
• \r (carriage return, ASCII 13) => \ + r (backslash + Alphabet r)
• \0 (ASCII 0) => \ + 0 (backslash + 0(ASCII 48)
• \  (backslash) => \ + \

You can assign the space where the result string will be saved by using the length parameter. It will take as much as the byte length of the maximum input string * 2 + 1.

int cci_execute(int req_handle, char flag, int max_col_size, T_CCI_ERROR *err_buf)¶

The cci_execute function executes the SQL statement (prepared statement) that has executed cci_prepare(). A request handle, flag, the maximum length of a column to be fetched, and the address of a T_CCI_ERROR construct variable in which error information being stored are specified as arguments.

Parameters:	req_handle -- (IN) Request handle of the prepared statement flag -- (IN) exec flag ( CCI_EXEC_ASYNC or CCI_EXEC_QUERY_ALL ) max_col_size -- (IN) The maximum length of a column to be fetched when it is a string data type in bytes. If this value is 0, full length is fetched. err_buf -- (OUT) Database error buffer
Returns:	SELECT : Returns the number of results in sync mode. Returns 0 in async mode. INSERT, UPDATE : Returns the number of rows reflected. Others queries : 0 Failure : Error code CCI_ER_REQ_HANDLE CCI_ER_BIND CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_QUERY_TIMEOUT CCI_ER_LOGIN_TIMEOUT

The function of retrieving the query result from the server by configuring flag can be classified as synchronous or asynchronous. Or it can be determined whether to execute multiple queries or one query. If the flag is set to CCI_EXEC_QUERY_ALL, a synchronous mode (sync_mode) is used to retrieve query results immediately after executing prepared queries if it is set to CCI_EXEC_ASYNC, an asynchronous mode (async_mode) is used to retrieve the result immediately each time a query result is created. The flag is set to CCI_EXEC_QUERY_ALL by default, and in such cases the following rules are applied.

Through a flag, the behavior of retrieving the query result from the server can be set as synchronous or asynchronous, and the way of query execution can be set as all queries or the first one.

If the flag is set as CCI_EXEC_ASYNC, an asynchronous mode is used to retrieve the result immediately each time a query result is created. If not, a synchronous mode is used to retrieve query results after executing prepared queries all.

If the flag is set to CCI_EXEC_QUERY_ALL, all prepared queries(separated by semicolon) are executed. If not, only the first query is executed.

If the flag is set to CCI_EXEC_QUERY_ALL, the following rules are applied.

• The return value is the result of the first query.
• If an error occurs in any query, the execution is processed as a failure.
• For a query composed of in a query composed of q1; q2; q3, even if an error occurs in q2 after q1 succeeds the execution, the result of q1 remains valid. That is, the previous successful query executions are not rolled back when an error occurs.
• If a query is executed successfully, the result of the second query can be obtained using cci_next_result().

max_col_size is a value that is used to determine the maximum length of a column to be sent to a client when the columns of the prepared statement are CHAR, VARCHAR, BIT or VARBIT. If this value is 0, full length is fetched.

int cci_execute_array(int req_handle, T_CCI_QUERY_RESULT **query_result, T_CCI_ERROR *err_buf)¶

If more than one value is bound to the prepared statement, this gets the values of the variables to be bound and executes the query by binding each value to the variable.

Parameters:	req_handle -- (IN) Request handle of the prepared statement query_result -- (OUT) Query results (the number of executed queries) err_buf -- (OUT) Database error buffer
Returns:	Success: The number of executed queries, Failure: Negative number CCI_ER_REQ_HANDLE CCI_ER_BIND CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_QUERY_TIMEOUT CCI_ER_LOGIN_TIMEOUT

To bind the data, call the cci_bind_param_array_size() function to specify the size of the array, bind each value to the variable by using the cci_bind_param_array() function, and execute the query by calling the cci_execute_array() function. The query result will be stored on the array of T_CCI_QUERY_RESULT structure.

You can get three execution results by calling the cci_execute() function. However, the cci_execute_array() function returns the number of queries executed by the query_result variable. You can use CCI_QUERY_RESULT_RESULT, CCI_QUERY_RESULT_ERR_NO, CCI_QUERY_RESULT_ERR_MSG and CCI_QUERY_RESULT_STMT_TYPE macros to get the result of each query.

Note that the validity check is not performed for each parameter entered in the macro.

After using the query_result variable, you must delete the query_result by using the cci_query_result_free() function.

Macro	Return Type	Meaning
CCI_QUERY_RESULT_RESULT	int	the number of results or error identifier (-1: CAS error, -2: DBMS error)
CCI_QUERY_RESULT_ERR_NO	int	error number about query
CCI_QUERY_RESULT_ERR_MSG	char *	error message about query
CCI_QUERY_RESULT_STMT_TYPE	int(T_CCI_CUBRID_STMT enum)	type of query statement

If autocommit mode is on, each query in the array is committed after executing.

Note

• In the previous version of 2008 R4.3, if the autocommit mode is on, all queries in the array were committed after all of them are executed. From 2008 R4.3 version, the transaction is committed every time when a query is executed.
• In autocommit mode off, if the general error occurs during executing one of the queries in the array on the cci_execute_array function which does a batch processing of the queries, the query with an error is ignored and the next query is executed continuously. But if the deadlock occurs, the error occurs as rolling back the transaction.

char *query =
    "update participant set gold = ? where host_year = ? and nation_code = 'KOR'";
int gold[2];
char *host_year[2];
int null_ind[2];
T_CCI_QUERY_RESULT *result;
int n_executed;
...

req = cci_prepare (con, query, 0, &cci_error);
if (req < 0)
{
    printf ("prepare error: %d, %s\n", cci_error.err_code, cci_error.err_msg);
    goto handle_error;
}

gold[0] = 20;
host_year[0] = "2004";

gold[1] = 15;
host_year[1] = "2008";

null_ind[0] = null_ind[1] = 0;
error = cci_bind_param_array_size (req, 2);
if (error < 0)
{
    printf ("bind_param_array_size error: %d\n", error);
    goto handle_error;
}

error =
    cci_bind_param_array (req, 1, CCI_A_TYPE_INT, gold, null_ind, CCI_U_TYPE_INT);
if (error < 0)
{
    printf ("bind_param_array error: %d\n", error);
    goto handle_error;
}
error =
    cci_bind_param_array (req, 2, CCI_A_TYPE_STR, host_year, null_ind, CCI_U_TYPE_INT);
if (error < 0)
{
    printf ("bind_param_array error: %d\n", error);
    goto handle_error;
}

n_executed = cci_execute_array (req, &result, &cci_error);
if (n_executed < 0)
{
    printf ("execute error: %d, %s\n", cci_error.err_code, cci_error.err_msg);
    goto handle_error;
}
for (i = 1; i <= n_executed; i++)
{
    printf ("query %d\n", i);
    printf ("result count = %d\n", CCI_QUERY_RESULT_RESULT (result, i));
    printf ("error message = %s\n", CCI_QUERY_RESULT_ERR_MSG (result, i));
    printf ("statement type = %d\n",
            CCI_QUERY_RESULT_STMT_TYPE (result, i));
}
error = cci_query_result_free (result, n_executed);
if (error < 0)
{
    printf ("query_result_free: %d\n", error);
    goto handle_error;
}
error = cci_end_tran(con, CCI_TRAN_COMMIT, &cci_error);
if (error < 0)
{
    printf ("end_tran: %d, %s\n", cci_error.err_code, cci_error.err_msg);
    goto handle_error;
}

int cci_execute_batch(int conn_handle, int num_sql_stmt, char **sql_stmt, T_CCI_QUERY_RESULT **query_result, T_CCI_ERROR *err_buf)¶

In CCI, multiple jobs can be processed simultaneously when using DML queries such as INSERT / UPDATE / DELETE. CCI_QUERY_RESULT_RESULT and cci_execute_batch() functions can be used to execute such batch jobs. Note that prepared statements cannot be used in the cci_execute_batch() function. The query result will be stored on the array of T_CCI_QUERY_RESULT structure.

Parameters:	conn_handle -- (IN) Connection handle num_sql_stmt -- (IN) The number of sql_stmt sql_stmt -- (IN) SQL statement array query_result -- (OUT) The results of sql_stmt err_buf -- (OUT) Database error buffer
Returns:	Success: The number of executed queries, Failure: Negative number CCI_ER_CON_HANDLE CCI_ER_DBMS CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY CCI_ER_CONNECT CCI_ER_QUERY_TIMEOUT CCI_ER_LOGIN_TIMEOUT

Executes sql_stmt as many times as num_sql_stmt specified as a parameter and returns the number of queries executed with the query_result variable. You can use CCI_QUERY_RESULT_RESULT, c:macro:CCI_QUERY_RESULT_ERR_NO, CCI_QUERY_RESULT_ERR_MSG and CCI_QUERY_RESULT_STMT_TYPE macros to get the result of each query. Regarding the summary of these macros, see the cci_execute_array() function.

Note that the validity check is not performed for each parameter entered in the macro.

After using the query_result variable, you must delete the query result by using the cci_query_result_free() function.

If autocommit mode is on, each query in the array is committed after executing.

Note

• In the previous version of 2008 R4.3, if the autocommit is on, all queries in the array were committed after all of them are executed. From 2008 R4.3 version, each query in the array is committed right after each running.
• If autocommit mode is off, after the general error occurs during executing one of the queries in the array on the cci_execute_batch function which does a batch processing of the queries, the query with an error is ignored and the next query is executed. But if the deadlock occurs, the error occurs as rolling back the transaction.

...
char **queries;
T_CCI_QUERY_RESULT *result;
int n_queries, n_executed;
...
count = 3;
queries = (char **) malloc (count * sizeof (char *));
queries[0] =
    "insert into athlete(name, gender, nation_code, event) values('Ji-sung Park', 'M', 'KOR', 'Soccer')";
queries[1] =
    "insert into athlete(name, gender, nation_code, event) values('Joo-young Park', 'M', 'KOR', 'Soccer')";
queries[2] =
    "select * from athlete order by code desc for orderby_num() < 3";

//calling cci_execute_batch()
n_executed = cci_execute_batch (con, count, queries, &result, &cci_error);
if (n_executed < 0)
{
    printf ("execute_batch: %d, %s\n", cci_error.err_code, cci_error.err_msg);
    goto handle_error;
}
printf ("%d statements were executed.\n", n_executed);

for (i = 1; i <= n_executed; i++)
{
    printf ("query %d\n", i);
    printf ("result count = %d\n", CCI_QUERY_RESULT_RESULT (result, i));
    printf ("error message = %s\n", CCI_QUERY_RESULT_ERR_MSG (result, i));
    printf ("statement type = %d\n",
            CCI_QUERY_RESULT_STMT_TYPE (result, i));
}

error = cci_query_result_free (result, n_executed);
if (error < 0)
{
    printf ("query_result_free: %d\n", error);
    goto handle_error;
}
...

int cci_execute_result(int req_handle, T_CCI_QUERY_RESULT **query_result, T_CCI_ERROR *err_buf)¶

The cci_execute_result  function stores the execution results (e.g. statement type, result count) performed by :c:func`cci_execute` to the array of T_CCI_QUERY_RESULT structure. You can use CCI_QUERY_RESULT_RESULT, CCI_QUERY_RESULT_ERR_NO, CCI_QUERY_RESULT_ERR_MSG, CCI_QUERY_RESULT_STMT_TYPE macros to get the results of each query. Regarding the summary of these macros, see the cci_execute_array() function.

Note that the validity check is not performed for each parameter entered in the macro.

The memory of used query results must be released by the cci_query_result_free() function.

Parameters:	req_handle -- (IN) Request handle of the prepared statement query_result -- (OUT) Query results err_buf -- (OUT) Database error buffer
Returns:	Success: The number of queries, Failure: Negative number CCI_ER_REQ_HANDLE CCI_ER_COMMUNICATION

...
T_CCI_QUERY_RESULT *qr;
...

cci_execute( ... );
res = cci_execute_result(req_h, &qr, &err_buf);
if (res < 0)
{
    /* error */
}
else
{
    for (i=1 ; i <= res ; i++)
    {
        result_count = CCI_QUERY_RESULT_RESULT(qr, i);
        stmt_type = CCI_QUERY_RESULT_STMT_TYPE(qr, i);
    }
    cci_query_result_free(qr, res);
}
...

int cci_fetch(int req_handle, T_CCI_ERROR *err_buf)¶

The cci_fetch function fetches the query result executed by cci_execute() from the server-side CAS and stores it to the client buffer. The cci_get_data() function can be used to identify the data of a specific column from the fetched query result.

Parameters:	req_handle -- (IN) Request handle err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CAS_ER_HOLDABLE_NOT_ALLOWED CCI_ER_NO_MORE_DATA CCI_ER_RESULT_SET_CLOSED CCI_ER_DELETED_TUPLE CCI_ER_COMMUNICATION CCI_ER_NO_MORE_MEMORY

int cci_fetch_buffer_clear(int req_handle)¶

The cci_fetch_buffer_clear function clears the records temporarily stored in the client buffer.

Parameters:	req_handle -- Request handle
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE

int cci_fetch_sensitive(int req_handle, T_CCI_ERROR *err_buf)¶

The cci_fetch_sensitive function sends changed values for sensitive column when the SELECT query result is delivered. If the results by req_handle are not sensitive, they are same as the ones by :c:func`cci_fetch`. The return value of CCI_ER_DELETED_TUPLE means that the given row has been deleted.

Parameters:	req_handle -- (IN) Request handle err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_NO_MORE_DATA CCI_ER_COMMUNICATION CCI_ER_DBMS CCI_ER_DELETED_TUPLE

sensitive column means the item that can provide updated value in the SELECT list when you re-request the results. For example, if a column is directly used as an item of the SELECT list without aggregation operation, this column can be called a sensitive column.

When you fetch the result again, the sensitive result receive the data from the server, not from the client buffer.

int cci_fetch_size(int req_handle, int fetch_size)¶

The cci_fetch_size function determines the number of records sent by cci_fetch() from the server to the client.

Parameters:	req_handle -- (IN) Request handle fetch_size -- (IN) fetch size
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE

CCI_AUTOCOMMIT_MODE cci_get_autocommit(int conn_handle)¶

The cci_get_autocommit function returns the auto-commit mode currently configured.

Parameters:	conn_handle -- (IN) Connection handle
Returns:	CCI_AUTOCOMMIT_TRUE: Auto-commit mode is ON, CCI_AUTOCOMMIT_FALSE: Auto-commit mode is OFF

int cci_get_bind_num(int req_handle)¶

The cci_get_bind_num function gets the number of input bindings. If the SQL statement used during preparation is composed of multiple queries, it represents the number of input bindings used in all queries.

Parameters:	req_handle -- (IN) Request handle for the prepared statement
Returns:	The number of input bindings CCI_ER_REQ_HANDLE

int cci_get_class_num_objs(int conn_handle, char *class_name, int flag, int *num_objs, int *num_pages, T_CCI_ERROR *err_buf)¶

The cci_get_class_num_objs function gets the number of objects of the class_name class and the number of pages being used. If the flag is configured to 1, an approximate value is fetched; if it is configured to 0, an exact value is fetched.

Parameters:	conn_handle -- (IN) Connection handle class_name -- (IN) Class name flag -- (IN) 0 or 1 num_objs -- (OUT) The number of objects num_pages -- (OUT) The number of pages err_buf -- (OUT) Database error buffer
Returns:	Error code (0: success) CCI_ER_REQ_HANDLE CCI_ER_COMMUNICATION CCI_ER_CONNECT