php_cubrid.c

/*
 * Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright notice,
 *   this list of conditions and the following disclaimer in the documentation
 *   and/or other materials provided with the distribution.
 *
 * - Neither the name of the <ORGANIZATION> nor the names of its contributors
 *   may be used to endorse or promote products derived from this software without
 *   specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
 * OF SUCH DAMAGE.
 *
 */

#define _CRT_SECURE_NO_WARNINGS

/************************************************************************
* IMPORTED SYSTEM HEADER FILES
************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "php_ini.h"
#include "php_globals.h"
#include "ext/standard/info.h"
#include "ext/standard/php_string.h"

#include "zend_exceptions.h"

#ifdef PHP_WIN32
#include <winsock.h>
#endif

/************************************************************************
* OTHER IMPORTED HEADER FILES
************************************************************************/

#include "php_cubrid.h"
#include "php_cubrid_version.h"
#include <cas_cci.h>
#include <fcntl.h>

/************************************************************************
* PRIVATE DEFINITIONS
************************************************************************/

#ifndef TRUE
# define TRUE 1
#endif
#ifndef FALSE
# define FALSE 0
#endif

#if PHP_MINOR_VERSION < 3
#define zend_parse_parameters_none() zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "")
#endif

#define CUBRID_LOB_READ_BUF_SIZE    8192

/* EXECUTE */
#define CUBRID_INCLUDE_OID	    1
#define CUBRID_ASYNC		    2
#define CUBRID_EXEC_QUERY_ALL       4

/* ARRAY */
typedef enum
{
    CUBRID_NUM = 1,
    CUBRID_ASSOC = 2,
    CUBRID_BOTH = CUBRID_NUM | CUBRID_ASSOC,
    CUBRID_OBJECT = 4,
    CUBRID_LOB = 8,
} T_CUBRID_ARRAY_TYPE;

/* CURSOR ORIGIN */
typedef enum
{
    CUBRID_CURSOR_FIRST = CCI_CURSOR_FIRST,
    CUBRID_CURSOR_CURRENT = CCI_CURSOR_CURRENT,
    CUBRID_CURSOR_LAST = CCI_CURSOR_LAST,
} T_CUBRID_CURSOR_ORIGIN;

/* SCHEMA */
#define CUBRID_SCH_CLASS		CCI_SCH_CLASS
#define CUBRID_SCH_VCLASS		CCI_SCH_VCLASS
#define CUBRID_SCH_QUERY_SPEC		CCI_SCH_QUERY_SPEC
#define CUBRID_SCH_ATTRIBUTE		CCI_SCH_ATTRIBUTE
#define CUBRID_SCH_CLASS_ATTRIBUTE	CCI_SCH_CLASS_ATTRIBUTE
#define CUBRID_SCH_METHOD		CCI_SCH_METHOD
#define CUBRID_SCH_CLASS_METHOD		CCI_SCH_CLASS_METHOD
#define CUBRID_SCH_METHOD_FILE		CCI_SCH_METHOD_FILE
#define CUBRID_SCH_SUPERCLASS		CCI_SCH_SUPERCLASS
#define CUBRID_SCH_SUBCLASS		CCI_SCH_SUBCLASS
#define CUBRID_SCH_CONSTRAINT		CCI_SCH_CONSTRAINT
#define CUBRID_SCH_TRIGGER		CCI_SCH_TRIGGER
#define CUBRID_SCH_CLASS_PRIVILEGE	CCI_SCH_CLASS_PRIVILEGE
#define CUBRID_SCH_ATTR_PRIVILEGE	CCI_SCH_ATTR_PRIVILEGE
#define CUBRID_SCH_DIRECT_SUPER_CLASS	CCI_SCH_DIRECT_SUPER_CLASS
#define CUBRID_SCH_PRIMARY_KEY		CCI_SCH_PRIMARY_KEY
#define CUBRID_SCH_IMPORTED_KEYS        CCI_SCH_IMPORTED_KEYS
#define CUBRID_SCH_EXPORTED_KEYS        CCI_SCH_EXPORTED_KEYS
#define CUBRID_SCH_CROSS_REFERENCE      CCI_SCH_CROSS_REFERENCE

/* ERROR FACILITY */
typedef enum
{
    CUBRID_FACILITY_DBMS = 1,
    CUBRID_FACILITY_CAS,
    CUBRID_FACILITY_CCI,
    CUBRID_FACILITY_CLIENT,
} T_FACILITY_CODE;

/* error codes */
#define CUBRID_ER_INVALID_SQL_TYPE 		-30002
#define CUBRID_ER_CANNOT_GET_COLUMN_INFO 	-30003
#define CUBRID_ER_INVALID_PARAM 		-30006
#define CUBRID_ER_NOT_SUPPORTED_TYPE 		-30008
#define CUBRID_ER_TRANSFER_FAIL 		-30011
#define CUBRID_ER_PHP				-30012
#define CUBRID_ER_PARAM_UNBIND                  -30015
#define CUBRID_ER_INVALID_PARAM_TYPE            -30022
#define CUBRID_ER_END                           -31000
/* CAUTION! Also add the error message string to db_error[] */

/* Maximum length for the Cubrid data types. 
 *
 * The max len of LOB is the max file size creatable in an external storage, 
 * so we ca't give the max len of LOB type, just use 1G. Please ignore it. 
 */
#define MAX_CUBRID_CHAR_LEN   1073741823
#define MAX_LEN_INTEGER	      (10 + 1)
#define MAX_LEN_SMALLINT      (5 + 1)
#define MAX_LEN_BIGINT	      (19 + 1)
#define MAX_LEN_FLOAT	      (14 + 1)
#define MAX_LEN_DOUBLE	      (28 + 1)
#define MAX_LEN_MONETARY      (28 + 2)
#define MAX_LEN_DATE	      10
#define MAX_LEN_TIME	      8
#define MAX_LEN_TIMESTAMP     23
#define MAX_LEN_DATETIME      MAX_LEN_TIMESTAMP
#define MAX_LEN_OBJECT	      MAX_CUBRID_CHAR_LEN
#define MAX_LEN_SET	      MAX_CUBRID_CHAR_LEN
#define MAX_LEN_MULTISET      MAX_CUBRID_CHAR_LEN
#define MAX_LEN_SEQUENCE      MAX_CUBRID_CHAR_LEN
#define MAX_LEN_LOB           MAX_CUBRID_CHAR_LEN

/* Max Cubrid supported charsets */
#define MAX_DB_CHARSETS 6

/* In CCI, CCI_U_TYPE_UNKNOWN == CCI_U_TYPE_NULL == 0, 
 * so use below macro to denote the UNKNOWN type */
#define U_TYPE_UNKNOWN -1
static struct cubrid_type2name_st{
  int   type;
  char* name;
} cubrid_type2name[] = {
    {CCI_U_TYPE_UNKNOWN ,      "unknown"},
    {CCI_U_TYPE_CHAR,     "char"},
    {CCI_U_TYPE_STRING,     "varchar"},
    {CCI_U_TYPE_NCHAR,     "nchar"},
    {CCI_U_TYPE_VARNCHAR,     "varnchar"},
    {CCI_U_TYPE_BIT,     "bit"},
    {CCI_U_TYPE_VARBIT,     "varbit"},
    {CCI_U_TYPE_NUMERIC,     "numeric"},
    {CCI_U_TYPE_INT,     "integer"},
    {CCI_U_TYPE_SHORT,     "smallint"},
    {CCI_U_TYPE_MONETARY,     "monetary"},
    {CCI_U_TYPE_FLOAT,     "float"},
    {CCI_U_TYPE_DOUBLE,     "double"},
    {CCI_U_TYPE_DATE,     "date"},
    {CCI_U_TYPE_TIME,     "time"},
    {CCI_U_TYPE_TIMESTAMP,     "timestamp"},
    {CCI_U_TYPE_SET,     "set"},
    {CCI_U_TYPE_MULTISET,     "multiset"},
    {CCI_U_TYPE_SEQUENCE,     "sequence"},
    {CCI_U_TYPE_OBJECT,     "object"},
    {CCI_U_TYPE_BIGINT,     "bigint"},
    {CCI_U_TYPE_DATETIME,     "datetime"},
    {CCI_U_TYPE_BLOB,     "blob"},
    {CCI_U_TYPE_CLOB,     "clob"},
    {CCI_U_TYPE_ENUM,     "enum"},
};

typedef struct
{
    int err_code;
    char *err_msg;
} DB_ERROR_INFO;

/* Define addtion error info */
static const DB_ERROR_INFO db_error[] = {
    {CUBRID_ER_INVALID_SQL_TYPE, "Invalid API call"},
    {CUBRID_ER_CANNOT_GET_COLUMN_INFO, "Cannot get column info"},
    {CUBRID_ER_INVALID_PARAM, "Invalid parameter"},
    {CUBRID_ER_NOT_SUPPORTED_TYPE, "Invalid type"},
    {CUBRID_ER_TRANSFER_FAIL, "Lob transfering error"},
    {CUBRID_ER_PHP, "PHP error"},
    {CUBRID_ER_PARAM_UNBIND, "Some parameter not binded"},
    {CUBRID_ER_INVALID_PARAM_TYPE, "Invalid db parameter type"},
};

typedef struct
{
    const char *charset_name;
    const char *charset_desc;
    const char *space_char;
    int charset_id;
    int default_collation;
    int space_size;
} DB_CHARSET;

/* Define Cubrid supported charsets, 
 * now we only use charset_name, so just set space_char to empty */
static const DB_CHARSET db_charsets[] = {
    {"ascii", "US English charset - ASCII encoding", "", 0, 0, 1},
    {"raw-bits", "Uninterpreted bits - Raw encoding", "", 1, 0, 1},
    {"raw-bytes", "Uninterpreted bytes - Raw encoding", "", 2, 0, 1},
    {"iso8859-1", "Latin 1 charset - ISO 8859 encoding", "", 3, 0, 1},
    {"ksc-euc", "KSC 5601 1990 charset - EUC encoding", "", 4, 0, 2},
    {"utf-8", "UNICODE charset - UTF-8 encoding", " ", 5, 0, 1},
    {"", "Unknown encoding", "", -1, 0, 0}
};

typedef struct
{
    char *type_name;
    T_CCI_U_TYPE cubrid_u_type;
    int len;
} DB_TYPE_INFO;

/* Define Cubrid supported date types */
static const DB_TYPE_INFO db_type_info[] = {
    {"NULL", CCI_U_TYPE_NULL, 0},
    {"UNKNOWN", U_TYPE_UNKNOWN, MAX_LEN_OBJECT},

    {"CHAR", CCI_U_TYPE_CHAR, -1},
    {"STRING", CCI_U_TYPE_STRING, -1},
    {"NCHAR", CCI_U_TYPE_NCHAR, -1},
    {"VARNCHAR", CCI_U_TYPE_VARNCHAR, -1},

    {"BIT", CCI_U_TYPE_BIT, -1},
    {"VARBIT", CCI_U_TYPE_VARBIT, -1},

    {"NUMERIC", CCI_U_TYPE_NUMERIC, -1},
    {"NUMBER", CCI_U_TYPE_NUMERIC, -1},
    {"INT", CCI_U_TYPE_INT, MAX_LEN_INTEGER},
    {"SHORT", CCI_U_TYPE_SHORT, MAX_LEN_SMALLINT},
    {"BIGINT", CCI_U_TYPE_BIGINT, MAX_LEN_BIGINT},
    {"MONETARY", CCI_U_TYPE_MONETARY, MAX_LEN_MONETARY},

    {"FLOAT", CCI_U_TYPE_FLOAT, MAX_LEN_FLOAT},
    {"DOUBLE", CCI_U_TYPE_DOUBLE, MAX_LEN_DOUBLE},

    {"DATE", CCI_U_TYPE_DATE, MAX_LEN_DATE},
    {"TIME", CCI_U_TYPE_TIME, MAX_LEN_TIME},
    {"DATETIME", CCI_U_TYPE_DATETIME, MAX_LEN_DATETIME},
    {"TIMESTAMP", CCI_U_TYPE_TIMESTAMP, MAX_LEN_TIMESTAMP},

    {"SET", CCI_U_TYPE_SET, MAX_LEN_SET},
    {"MULTISET", CCI_U_TYPE_MULTISET, MAX_LEN_MULTISET},
    {"SEQUENCE", CCI_U_TYPE_SEQUENCE, MAX_LEN_SEQUENCE},
    {"RESULTSET", CCI_U_TYPE_RESULTSET, -1},

    {"OBJECT", CCI_U_TYPE_OBJECT, MAX_LEN_OBJECT},
    {"BLOB", CCI_U_TYPE_BLOB, MAX_LEN_LOB},
    {"CLOB", CCI_U_TYPE_CLOB, MAX_LEN_LOB},
    {"ENUM", CCI_U_TYPE_ENUM, -1},
};

/* DB parameters */
#define CUBRID_PARAM_ISOLATION_LEVEL    CCI_PARAM_ISOLATION_LEVEL
#define CUBRID_PARAM_LOCK_TIMEOUT       CCI_PARAM_LOCK_TIMEOUT

#define CUBRID_AUTOCOMMIT_FALSE    CCI_AUTOCOMMIT_FALSE
#define CUBRID_AUTOCOMMIT_TRUE     CCI_AUTOCOMMIT_TRUE

/* Define CUBRID DB parameters */
typedef struct
{
    T_CCI_DB_PARAM parameter_id;
    const char *parameter_name;
} DB_PARAMETER;

static const DB_PARAMETER db_parameters[] = {
    {CCI_PARAM_ISOLATION_LEVEL, "PARAM_ISOLATION_LEVEL"},
    {CCI_PARAM_LOCK_TIMEOUT, "PARAM_LOCK_TIMEOUT"},
    {CCI_PARAM_MAX_STRING_LENGTH, "PARAM_MAX_STRING_LENGTH"},
    {CCI_PARAM_AUTO_COMMIT, "PARAM_AUTO_COMMIT"}
};

/************************************************************************
* PRIVATE TYPE DEFINITIONS
************************************************************************/

#ifdef PHP_WIN32
typedef __int64 php_cubrid_int64_t;
typedef unsigned __int64 php_cubrid_uint64_t;

#define stricmp(s1, s2) _stricmp(s1, s2)
#define strnicmp(s1, s2, n) _strnicmp(s1, s2, n)
#define open(fd, mode, flag) _open(fd, mode, flag)
#define write(fd, buf, size) _write(fd, buf, size)
#define read(fd, buf, size) _read(fd, buf, size)
#define close(fd) _close(fd)
#define unlink(file_name) _unlink(file_name)
#define strtoll(nptr, endptr, base) _strtoi64(nptr, endptr, base)

#else
typedef long long int php_cubrid_int64_t;
typedef unsigned long long int php_cubrid_uint64_t;
#endif

typedef void *T_CCI_LOB;

typedef struct
{
    T_CCI_LOB lob;
    T_CCI_U_TYPE type;
    php_cubrid_int64_t size;
} T_CUBRID_LOB;

typedef struct cubrid_request T_CUBRID_REQUEST;
typedef struct cubrid_lob2 T_CUBRID_LOB2;

typedef struct linked_list_node {
    void *data;
    struct linked_list_node *next;
} LINKED_LIST_NODE;

typedef struct linked_list {
    LINKED_LIST_NODE *head;
    LINKED_LIST_NODE *tail;
} LINKED_LIST;

typedef struct
{
    T_CUBRID_ERROR recent_error;
    int handle;
    int persistent;

    int affected_rows;
    T_CCI_CUBRID_STMT sql_type;

    LINKED_LIST *unclosed_requests;
} T_CUBRID_CONNECT;

struct cubrid_request
{
    T_CUBRID_CONNECT *conn;

    int handle;
    int col_count;
    int row_count;
    int l_prepare;
    int bind_num;
    int *field_lengths;
    short *l_bind;
    int fetch_field_auto_index;
    T_CCI_CUBRID_STMT sql_type;
    T_CCI_COL_INFO *col_info;
    T_CUBRID_LOB *lob;

    T_CUBRID_LOB2 **lob2_list;

};

struct cubrid_lob2
{
    T_CUBRID_CONNECT *connect;
    T_CUBRID_REQUEST *request;

    T_CCI_LOB lob;
    T_CCI_U_TYPE type;
    php_cubrid_int64_t pos;
};

/************************************************************************
* PRIVATE FUNCTION PROTOTYPES
************************************************************************/

static void php_cubrid_init_globals(zend_cubrid_globals *cubrid_globals);

static void close_cubrid_pconnect(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void close_cubrid_connect(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void close_cubrid_request(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void close_cubrid_lob(zend_rsrc_list_entry *rsrc TSRMLS_DC);
static void close_cubrid_lob2(zend_rsrc_list_entry *rsrc TSRMLS_DC);

static void close_cubrid_request_internal(T_CUBRID_REQUEST *req);
static void close_cubrid_lob_internal(T_CUBRID_LOB *lob);

static int init_error(void);
static int set_error(T_FACILITY_CODE facility, int code, char *msg, ...);
static int init_error_link(T_CUBRID_CONNECT *conn);
static int set_error_link(T_CUBRID_CONNECT *conn, int code, char *msg, ...);
static int get_error_msg(int err_code, char *buf, int buf_size);
static int handle_error(int err_code, T_CCI_ERROR *error, T_CUBRID_CONNECT *conn);

static void php_cubrid_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent);
static void php_cubrid_do_connect_with_url(INTERNAL_FUNCTION_PARAMETERS, int persistent);

static T_CUBRID_CONNECT *new_cubrid_connect(int persistent);
static T_CUBRID_REQUEST *new_cubrid_request(void);
static T_CUBRID_LOB *new_cubrid_lob(void);
static T_CUBRID_LOB2 *new_cubrid_lob2(void);
static void register_cubrid_request(T_CUBRID_CONNECT *conn, T_CUBRID_REQUEST *req);

static void php_cubrid_set_default_conn(int id TSRMLS_DC);
static void php_cubrid_set_default_req(int id TSRMLS_DC);
static void php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long type, int is_object);

static int fetch_a_row(zval *arg, T_CUBRID_CONNECT *connect, int req_handle, T_CUBRID_REQUEST *reqeust, int type TSRMLS_DC);
static int type2str(T_CCI_COL_INFO *column_info, char *type_name, int type_name_len);

static int cubrid_make_set(HashTable *ht, T_CCI_SET *set);
static int cubrid_add_index_array(zval *arg, uint index, T_CCI_SET in_set TSRMLS_DC);
static int cubrid_add_assoc_array(zval *arg, char *key, T_CCI_SET in_set TSRMLS_DC);
static int cubrid_array_destroy(HashTable *ht ZEND_FILE_LINE_DC);

static int numeric_type(T_CCI_U_TYPE type);
static int get_cubrid_u_type_by_name(const char *type_name);
static int get_cubrid_u_type_len(T_CCI_U_TYPE type);

static int cubrid_lob_new(int con_h_id, T_CCI_LOB *lob, T_CCI_U_TYPE type, T_CCI_ERROR *err_buf);
static php_cubrid_int64_t cubrid_lob_size(T_CCI_LOB lob, T_CCI_U_TYPE type);
static int cubrid_lob_write(int con_h_id, T_CCI_LOB lob, T_CCI_U_TYPE type, php_cubrid_int64_t start_pos, int length, const char *buf, T_CCI_ERROR *err_buf);
static int cubrid_lob_read(int con_h_id, T_CCI_LOB lob, T_CCI_U_TYPE type, php_cubrid_int64_t start_pos, int length, char *buf, T_CCI_ERROR *err_buf);
static int cubrid_lob_free(T_CCI_LOB lob, T_CCI_U_TYPE type);

static char *php_cubrid_int64_to_str(php_cubrid_int64_t i64 TSRMLS_DC);

static int cubrid_get_charset_internal(int conn, T_CCI_ERROR *error);

static void linked_list_append(LINKED_LIST *list, void *data);
static void linked_list_delete(LINKED_LIST *list, void *data);

/************************************************************************
* INTERFACE VARIABLES
************************************************************************/

char *cci_client_name = "PHP";

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_version, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_connect, 0, 0, 3)
    ZEND_ARG_INFO(0, host)
    ZEND_ARG_INFO(0, port)
    ZEND_ARG_INFO(0, dbname)
    ZEND_ARG_INFO(0, userid)
    ZEND_ARG_INFO(0, passwd)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_pconnect, 0, 0, 3)
    ZEND_ARG_INFO(0, host)
    ZEND_ARG_INFO(0, port)
    ZEND_ARG_INFO(0, dbname)
    ZEND_ARG_INFO(0, userid)
    ZEND_ARG_INFO(0, passwd)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_connect_with_url, 0, 0, 1)
    ZEND_ARG_INFO(0, url)
    ZEND_ARG_INFO(0, userid)
    ZEND_ARG_INFO(0, passwd)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_pconnect_with_url, 0, 0, 1)
    ZEND_ARG_INFO(0, url)
    ZEND_ARG_INFO(0, userid)
    ZEND_ARG_INFO(0, passwd)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_close, 0, 0, 0)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_prepare, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, prepare_stmt)
    ZEND_ARG_INFO(0, option)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_bind, 0, 0, 3)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, bind_index)
    ZEND_ARG_INFO(0, bind_value)
    ZEND_ARG_INFO(0, bind_value_type)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_execute, 0, 0, 1)
    ZEND_ARG_INFO(0, id)
    ZEND_ARG_INFO(0, sql_stmt)
    ZEND_ARG_INFO(0, option)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_batch_execute, 0, 0, 1)
    ZEND_ARG_INFO(0, id)
    ZEND_ARG_INFO(0, sql_stmt)
    ZEND_ARG_INFO(0, option)
ZEND_END_ARG_INFO()


ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_next_result, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_affected_rows, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_close_request, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, type)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_current_oid, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_column_types, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_column_names, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_move_cursor, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
    ZEND_ARG_INFO(0, origin)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_num_rows, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_num_cols, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_put, 0, 0, 3)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr)
    ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_drop, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_is_instance, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lock_read, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lock_write, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_class_name, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_schema, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, schema_type)
    ZEND_ARG_INFO(0, class_name)
    ZEND_ARG_INFO(0, attr_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_col_size, 0, 0, 3)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_col_get, 0, 0, 3)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_set_add, 0, 0, 4)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
    ZEND_ARG_INFO(0, set_element)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_set_drop, 0, 0, 4)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
    ZEND_ARG_INFO(0, set_element)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_seq_insert, 0, 0, 5)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
    ZEND_ARG_INFO(0, index)
    ZEND_ARG_INFO(0, set_element)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_seq_put, 0, 0, 5)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
    ZEND_ARG_INFO(0, index)
    ZEND_ARG_INFO(0, set_element)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_seq_drop, 0, 0, 4)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, oid)
    ZEND_ARG_INFO(0, attr_name)
    ZEND_ARG_INFO(0, index)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_autocommit, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_set_autocommit, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, mode)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_commit, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_rollback, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_error_msg, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_error_code, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_error_code_facility, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_errno, 0)
    ZEND_ARG_INFO(0, conn)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_error, 0)
    ZEND_ARG_INFO(0, conn)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_name, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_table, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_type, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_flags, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_data_seek, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_array, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, type)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_assoc, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_row, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_field, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_num_fields, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_free_result, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_lengths, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_fetch_object, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, class_name)
    ZEND_ARG_INFO(0, params)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_seek, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_field_len, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, offset)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_result, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, row)
    ZEND_ARG_INFO(0, field)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_unbuffered_query, 0, 0, 1)
    ZEND_ARG_INFO(0, query)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_query, 0, 0, 1)
    ZEND_ARG_INFO(0, query)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_charset, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_client_encoding, 0, 0, 0)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO(arginfo_cubrid_get_client_info, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_server_info, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_real_escape_string, 0, 0, 1)
    ZEND_ARG_INFO(0, unescaped_string)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_db_parameter, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_set_db_parameter, 0, 0, 3)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, param_type)
    ZEND_ARG_INFO(0, param_value)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_list_dbs, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_db_name, 0, 0, 2)
    ZEND_ARG_INFO(0, result)
    ZEND_ARG_INFO(0, row)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lnsert_id, 0, 0, 0)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_ping, 0, 0, 0)
    ZEND_ARG_INFO(0, conn_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_new, 0, 0, 1)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, type)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_bind, 0, 0, 3)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, bind_index)
    ZEND_ARG_INFO(0, bind_value)
    ZEND_ARG_INFO(0, bind_value_type)
ZEND_END_ARG_INFO()
 
ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_export, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, file_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_import, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, file_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_read, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, len)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_write, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, buf)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_tell, 0, 0, 1)
    ZEND_ARG_INFO(0, lob2_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_tell64, 0, 0, 1)
    ZEND_ARG_INFO(0, lob2_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_seek, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, offset)
    ZEND_ARG_INFO(0, origin)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_seek64, 0, 0, 2)
    ZEND_ARG_INFO(0, lob2_id)
    ZEND_ARG_INFO(0, offset)
    ZEND_ARG_INFO(0, origin)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_size, 0, 0, 1)
    ZEND_ARG_INFO(0, lob2_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_size64, 0, 0, 1)
    ZEND_ARG_INFO(0, lob2_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob2_close, 0, 0, 1)
    ZEND_ARG_INFO(0, lob2_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob_get, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, sql_stmt)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob_size, 0, 0, 1)
    ZEND_ARG_INFO(0, lob_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob_export, 0, 0, 3)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, lob_id)
    ZEND_ARG_INFO(0, file_name)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob_send, 0, 0, 2)
    ZEND_ARG_INFO(0, conn_id)
    ZEND_ARG_INFO(0, lob_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_lob_close, 0, 0, 1)
    ZEND_ARG_INFO(0, lob_id_array)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_get_query_timeout, 0, 0, 1)
    ZEND_ARG_INFO(0, req_id)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_cubrid_set_query_timeout, 0, 0, 2)
    ZEND_ARG_INFO(0, req_id)
    ZEND_ARG_INFO(0, timeout)
ZEND_END_ARG_INFO()

zend_function_entry cubrid_functions[] = {
    ZEND_FE(cubrid_version, arginfo_cubrid_version)
    ZEND_FE(cubrid_connect, arginfo_cubrid_connect)
    ZEND_FE(cubrid_pconnect, arginfo_cubrid_pconnect)
    ZEND_FE(cubrid_connect_with_url, arginfo_cubrid_connect_with_url)
    ZEND_FE(cubrid_pconnect_with_url, arginfo_cubrid_pconnect_with_url)
    ZEND_FE(cubrid_close, arginfo_cubrid_close)
    ZEND_FE(cubrid_prepare, arginfo_cubrid_prepare)
    ZEND_FE(cubrid_bind, arginfo_cubrid_bind)
    ZEND_FE(cubrid_execute, arginfo_cubrid_execute)
    ZEND_FE(cubrid_batch_execute, arginfo_cubrid_batch_execute)
    ZEND_FE(cubrid_next_result, arginfo_cubrid_next_result)
    ZEND_FE(cubrid_affected_rows, arginfo_cubrid_affected_rows)
    ZEND_FE(cubrid_close_request, arginfo_cubrid_close_request)
    ZEND_FE(cubrid_fetch, arginfo_cubrid_fetch)
    ZEND_FE(cubrid_current_oid, arginfo_cubrid_current_oid)
    ZEND_FE(cubrid_column_types, arginfo_cubrid_column_types)
    ZEND_FE(cubrid_column_names, arginfo_cubrid_column_names)
    ZEND_FE(cubrid_move_cursor, arginfo_cubrid_move_cursor)
    ZEND_FE(cubrid_num_rows, arginfo_cubrid_num_rows)
    ZEND_FE(cubrid_num_cols, arginfo_cubrid_num_cols)
    ZEND_FE(cubrid_get, arginfo_cubrid_get)
    ZEND_FE(cubrid_put, arginfo_cubrid_put)
    ZEND_FE(cubrid_drop, arginfo_cubrid_drop)
    ZEND_FE(cubrid_is_instance, arginfo_cubrid_is_instance)
    ZEND_FE(cubrid_lock_read, arginfo_cubrid_lock_read)
    ZEND_FE(cubrid_lock_write, arginfo_cubrid_lock_write)
    ZEND_FE(cubrid_get_class_name, arginfo_cubrid_get_class_name)
    ZEND_FE(cubrid_schema, arginfo_cubrid_schema)
    ZEND_FE(cubrid_col_size, arginfo_cubrid_col_size)
    ZEND_FE(cubrid_col_get, arginfo_cubrid_col_get)
    ZEND_FE(cubrid_set_add, arginfo_cubrid_set_add)
    ZEND_FE(cubrid_set_drop, arginfo_cubrid_set_drop)
    ZEND_FE(cubrid_seq_insert, arginfo_cubrid_seq_insert)
    ZEND_FE(cubrid_seq_put, arginfo_cubrid_seq_put)
    ZEND_FE(cubrid_seq_drop, arginfo_cubrid_seq_drop)
    ZEND_FE(cubrid_get_autocommit, arginfo_cubrid_get_autocommit)
    ZEND_FE(cubrid_set_autocommit, arginfo_cubrid_set_autocommit)
    ZEND_FE(cubrid_commit, arginfo_cubrid_commit)
    ZEND_FE(cubrid_rollback, arginfo_cubrid_rollback)
    ZEND_FE(cubrid_error_msg, arginfo_cubrid_error_msg)
    ZEND_FE(cubrid_error_code, arginfo_cubrid_error_code)
    ZEND_FE(cubrid_error_code_facility, arginfo_cubrid_error_code_facility)
    ZEND_FE(cubrid_errno, arginfo_cubrid_errno)
    ZEND_FE(cubrid_error, arginfo_cubrid_error)
    ZEND_FE(cubrid_field_name, arginfo_cubrid_field_name)
    ZEND_FE(cubrid_field_table, arginfo_cubrid_field_table)
    ZEND_FE(cubrid_field_type, arginfo_cubrid_field_type)
    ZEND_FE(cubrid_field_flags, arginfo_cubrid_field_flags)
    ZEND_FE(cubrid_data_seek, arginfo_cubrid_data_seek)
    ZEND_FE(cubrid_fetch_array, arginfo_cubrid_fetch_array)
    ZEND_FE(cubrid_fetch_assoc, arginfo_cubrid_fetch_assoc)
    ZEND_FE(cubrid_fetch_row, arginfo_cubrid_fetch_row)
    ZEND_FE(cubrid_fetch_field, arginfo_cubrid_fetch_field)
    ZEND_FE(cubrid_num_fields, arginfo_cubrid_num_fields)
    ZEND_FE(cubrid_free_result, arginfo_cubrid_free_result)
    ZEND_FE(cubrid_fetch_lengths, arginfo_cubrid_fetch_lengths)
    ZEND_FE(cubrid_fetch_object, arginfo_cubrid_fetch_object)
    ZEND_FE(cubrid_field_seek, arginfo_cubrid_field_seek)
    ZEND_FE(cubrid_field_len, arginfo_cubrid_field_len)
    ZEND_FE(cubrid_result, arginfo_cubrid_result)
    ZEND_FE(cubrid_get_charset, arginfo_cubrid_get_charset)
    ZEND_FE(cubrid_client_encoding, arginfo_cubrid_client_encoding)
    ZEND_FE(cubrid_unbuffered_query, arginfo_cubrid_unbuffered_query)
    ZEND_FE(cubrid_query, arginfo_cubrid_query)
    ZEND_FE(cubrid_get_client_info, arginfo_cubrid_get_client_info)
    ZEND_FE(cubrid_get_server_info, arginfo_cubrid_get_server_info)
    ZEND_FE(cubrid_real_escape_string, arginfo_cubrid_real_escape_string)
    ZEND_FE(cubrid_get_db_parameter, arginfo_cubrid_get_db_parameter)
    ZEND_FE(cubrid_set_db_parameter, arginfo_cubrid_set_db_parameter)
    ZEND_FE(cubrid_list_dbs, arginfo_cubrid_list_dbs)
    ZEND_FE(cubrid_db_name, arginfo_cubrid_db_name)
    ZEND_FE(cubrid_insert_id, arginfo_cubrid_lnsert_id)
    ZEND_FE(cubrid_ping, arginfo_cubrid_ping)

    ZEND_FE(cubrid_lob2_new, arginfo_cubrid_lob2_new)
    ZEND_FE(cubrid_lob2_bind, arginfo_cubrid_lob2_bind)
    ZEND_FE(cubrid_lob2_export, arginfo_cubrid_lob2_export)
    ZEND_FE(cubrid_lob2_import, arginfo_cubrid_lob2_import)
    ZEND_FE(cubrid_lob2_read, arginfo_cubrid_lob2_read)
    ZEND_FE(cubrid_lob2_write, arginfo_cubrid_lob2_write)
    ZEND_FE(cubrid_lob2_tell, arginfo_cubrid_lob2_tell)
    ZEND_FE(cubrid_lob2_tell64, arginfo_cubrid_lob2_tell64)
    ZEND_FE(cubrid_lob2_seek, arginfo_cubrid_lob2_seek)
    ZEND_FE(cubrid_lob2_seek64, arginfo_cubrid_lob2_seek64)
    ZEND_FE(cubrid_lob2_size, arginfo_cubrid_lob2_size)
    ZEND_FE(cubrid_lob2_size64, arginfo_cubrid_lob2_size64)
    ZEND_FE(cubrid_lob2_close, arginfo_cubrid_lob2_close)

    ZEND_FE(cubrid_lob_get, arginfo_cubrid_lob_get)
    ZEND_FE(cubrid_lob_size, arginfo_cubrid_lob_size)
    ZEND_FE(cubrid_lob_export, arginfo_cubrid_lob_export)
    ZEND_FE(cubrid_lob_send, arginfo_cubrid_lob_send)
    ZEND_FE(cubrid_lob_close, arginfo_cubrid_lob_close)
    ZEND_FE(cubrid_get_query_timeout, arginfo_cubrid_get_query_timeout)
    ZEND_FE(cubrid_set_query_timeout, arginfo_cubrid_set_query_timeout)
    ZEND_FALIAS(cubrid_close_prepare, cubrid_close_request, NULL) 
    ZEND_FALIAS(cubrid_disconnect, cubrid_close, NULL) 
    {NULL, NULL, NULL}
};

zend_module_entry cubrid_module_entry = {
    STANDARD_MODULE_HEADER,
    "CUBRID",
    cubrid_functions,
    ZEND_MINIT(cubrid),
    ZEND_MSHUTDOWN(cubrid),
    ZEND_RINIT(cubrid),
    ZEND_RSHUTDOWN(cubrid),
    ZEND_MINFO(cubrid),
    NO_VERSION_YET,
    STANDARD_MODULE_PROPERTIES
};

ZEND_DECLARE_MODULE_GLOBALS(cubrid)

/************************************************************************
* CUBRID PHP.INI SETTINGS
************************************************************************/

ZEND_INI_BEGIN()
/* maybe add settings later */
ZEND_INI_END()

/************************************************************************
* PRIVATE VARIABLES
************************************************************************/

/* resource type */
static int le_pconnect, le_connect, le_request, le_lob, le_lob2;

/************************************************************************
* IMPLEMENTATION OF CALLBACK FUNCTION (EXPORT/INIT/SHUTDOWN/INFO)
************************************************************************/

#if defined(COMPILE_DL_CUBRID)
ZEND_GET_MODULE(cubrid)
#endif

ZEND_MINIT_FUNCTION(cubrid)
{
    REGISTER_INI_ENTRIES();

    cci_init();

    ZEND_INIT_MODULE_GLOBALS(cubrid, php_cubrid_init_globals, NULL);

    le_pconnect = zend_register_list_destructors_ex(NULL, close_cubrid_pconnect, "CUBRID Connect Persistent", module_number);
    le_connect = zend_register_list_destructors_ex(close_cubrid_connect, NULL, "CUBRID Connect", module_number);
    le_request = zend_register_list_destructors_ex(close_cubrid_request, NULL, "CUBRID Request", module_number);
    le_lob = zend_register_list_destructors_ex(close_cubrid_lob, NULL, "CUBRID Lob", module_number);
    le_lob2 = zend_register_list_destructors_ex(close_cubrid_lob2, NULL, "CUBRID Lob2", module_number);

    Z_TYPE(cubrid_module_entry) = type;

    init_error();

    REGISTER_LONG_CONSTANT("CUBRID_INCLUDE_OID", CUBRID_INCLUDE_OID, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_ASYNC", CUBRID_ASYNC, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_EXEC_QUERY_ALL", CUBRID_EXEC_QUERY_ALL, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("CUBRID_NUM", CUBRID_NUM, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_ASSOC", CUBRID_ASSOC, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_BOTH", CUBRID_BOTH, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_OBJECT", CUBRID_OBJECT, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_LOB", CUBRID_LOB, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("CUBRID_CURSOR_FIRST", CUBRID_CURSOR_FIRST, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_CURSOR_CURRENT", CUBRID_CURSOR_CURRENT, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_CURSOR_LAST", CUBRID_CURSOR_LAST, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("CUBRID_PARAM_ISOLATION_LEVEL", CUBRID_PARAM_ISOLATION_LEVEL, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_PARAM_LOCK_TIMEOUT", CUBRID_PARAM_LOCK_TIMEOUT, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_AUTOCOMMIT_FALSE", CUBRID_AUTOCOMMIT_FALSE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_AUTOCOMMIT_TRUE", CUBRID_AUTOCOMMIT_TRUE, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("TRAN_REP_CLASS_COMMIT_INSTANCE", TRAN_REP_CLASS_COMMIT_INSTANCE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("TRAN_REP_CLASS_REP_INSTANCE", TRAN_REP_CLASS_REP_INSTANCE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("TRAN_SERIALIZABLE", TRAN_SERIALIZABLE, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("CUBRID_SCH_CLASS", CUBRID_SCH_CLASS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_VCLASS", CUBRID_SCH_VCLASS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_QUERY_SPEC", CUBRID_SCH_QUERY_SPEC, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_ATTRIBUTE", CUBRID_SCH_ATTRIBUTE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_CLASS_ATTRIBUTE", CUBRID_SCH_CLASS_ATTRIBUTE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_METHOD", CUBRID_SCH_METHOD, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_CLASS_METHOD", CUBRID_SCH_CLASS_METHOD, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_METHOD_FILE", CUBRID_SCH_METHOD_FILE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_SUPERCLASS", CUBRID_SCH_SUPERCLASS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_SUBCLASS", CUBRID_SCH_SUBCLASS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_CONSTRAINT", CUBRID_SCH_CONSTRAINT, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_TRIGGER", CUBRID_SCH_TRIGGER, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_CLASS_PRIVILEGE", CUBRID_SCH_CLASS_PRIVILEGE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_ATTR_PRIVILEGE", CUBRID_SCH_ATTR_PRIVILEGE, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_DIRECT_SUPER_CLASS", CUBRID_SCH_DIRECT_SUPER_CLASS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_PRIMARY_KEY", CUBRID_SCH_PRIMARY_KEY, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_IMPORTED_KEYS", CUBRID_SCH_IMPORTED_KEYS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_EXPORTED_KEYS", CUBRID_SCH_EXPORTED_KEYS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_SCH_CROSS_REFERENCE", CUBRID_SCH_CROSS_REFERENCE, CONST_CS | CONST_PERSISTENT);

    REGISTER_LONG_CONSTANT("CUBRID_FACILITY_DBMS", CUBRID_FACILITY_DBMS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_FACILITY_CAS", CUBRID_FACILITY_CAS, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_FACILITY_CCI", CUBRID_FACILITY_CCI, CONST_CS | CONST_PERSISTENT);
    REGISTER_LONG_CONSTANT("CUBRID_FACILITY_CLIENT", CUBRID_FACILITY_CLIENT, CONST_CS | CONST_PERSISTENT);

    return SUCCESS;
}

ZEND_MSHUTDOWN_FUNCTION(cubrid)
{
    UNREGISTER_INI_ENTRIES();
    cci_end();

    return SUCCESS;
}

ZEND_RINIT_FUNCTION(cubrid)
{
	CUBRID_G(last_connect_id) = -1;
	CUBRID_G(last_request_id) = -1;

	CUBRID_G(recent_error).code = 0;
	CUBRID_G(recent_error).facility = 0;
	CUBRID_G(recent_error).msg[0] = 0;

	return SUCCESS;
}

static int php_cubrid_persistent_helper(zend_rsrc_list_entry *le TSRMLS_DC)
{
    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval;
    LINKED_LIST_NODE *head, *p;

    if (Z_TYPE_P(le) != le_pconnect) {
        return 0;
    }

    connect = (T_CUBRID_CONNECT *)le->ptr;

    head = connect->unclosed_requests->head;

    for (p = head->next; p != NULL; p = head->next) {
        T_CUBRID_REQUEST *req = (T_CUBRID_REQUEST *)p->data;
        req->conn = NULL;
        req->handle = 0;

        if (req->lob2_list != NULL) {
            int i;
            for (i = 0; i < req->col_count; i++) {
                if (req->lob2_list[i]) {
                    req->lob2_list[i]->connect = NULL;
                    req->lob2_list[i] = NULL;
                }
            }
        }

        p->data = NULL; 
        head->next = p->next;
        efree(p);
    }

    connect->unclosed_requests->tail = head;

    if ((cubrid_retval = cci_end_tran (connect->handle, CCI_TRAN_ROLLBACK, &error)) < 0) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot rollback transaction when shutdown request");
        return -1;
    }

    return 0;
}

ZEND_RSHUTDOWN_FUNCTION(cubrid)
{
    zend_hash_apply(&EG(persistent_list), (apply_func_t)php_cubrid_persistent_helper TSRMLS_CC);
    return SUCCESS;
}

ZEND_MINFO_FUNCTION(cubrid)
{
    int major, minor, patch;
    char info[128];

    cci_get_version(&major, &minor, &patch);

    snprintf(info, sizeof(info), "%d.%d.%d", major, minor, patch);
    
    php_info_print_table_start();
    php_info_print_table_header(2, "CUBRID support", "enabled");
    php_info_print_table_row(2, "Driver Version", PHP_CUBRID_VERSION);
    php_info_print_table_row(2, "CCI Version", info);
    php_info_print_table_end();

    DISPLAY_INI_ENTRIES();
}

/************************************************************************
* IMPLEMENTATION OF CUBRID API
************************************************************************/

ZEND_FUNCTION(cubrid_version)
{
    if (zend_parse_parameters_none() == FAILURE) {
	return;
    }

    RETURN_STRINGL(PHP_CUBRID_VERSION, strlen(PHP_CUBRID_VERSION), 1);
}

static int check_connect_alive(T_CUBRID_CONNECT *connect)
{
    int req_handle = 0;

    T_CCI_ERROR error;
    int cubrid_retval = 0, connected = 0;
    int result = 0, ind = 0;
    char *query = "SELECT 1 FROM db_root";

    init_error();
    init_error_link(connect);

    if ((cubrid_retval = cci_prepare(connect->handle, query, 0, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        return 0;
    }

    req_handle = cubrid_retval;

    if ((cubrid_retval = cci_execute(req_handle, 0, 0, &error)) < 0) {
        goto HANDLE_ERROR;
    }

    cci_close_req_handle(req_handle);

    return 1;

HANDLE_ERROR:
    cci_close_req_handle(req_handle);
    return 0;
}

static void php_cubrid_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
    char *host = NULL, *dbname = NULL, *userid = NULL, *passwd = NULL, *attr = NULL;
    long port = 0;
    int host_len, dbname_len, userid_len, passwd_len, attr_len;

    int cubrid_conn, cubrid_retval = 0;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    char hashed_details[1024] = {'\0'};
    int hashed_details_length;

	char connect_url[2048] = {'\0'};

    zend_bool new_link = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sls|ssbs", 
		&host, &host_len, &port, &dbname, &dbname_len, 
		&userid, &userid_len, &passwd, &passwd_len, &new_link, &attr, &attr_len) == FAILURE) {
	return;
    }

    if (!userid) {
	userid = CUBRID_G(default_userid);
    }

    if (!passwd) {
	passwd = CUBRID_G(default_passwd);
    }

    snprintf(hashed_details, sizeof(hashed_details), "CUBRID:%s:%d:%s:%s:%s", host, (int)port, dbname, userid, passwd);
    hashed_details_length = strlen(hashed_details);

	if (attr) {
		snprintf(connect_url, sizeof(connect_url), "cci:CUBRID:%s:%d:%s:%s:%s:?%s", host, (int)port, dbname, userid, passwd, attr);
	} else {
		snprintf(connect_url, sizeof(connect_url), "cci:CUBRID:%s:%d:%s:%s:%s:", host, (int)port, dbname, userid, passwd);
	}

    if (persistent) {
        zend_rsrc_list_entry *le;

        /* try to find if we already have this link in our persistent list */
        if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_length+1, (void **) &le) == FAILURE) { /* we don't */
            zend_rsrc_list_entry new_le;

			if ((cubrid_conn = cci_connect_with_url_ex(connect_url, userid, passwd, &error)) < 0) {
				handle_error(cubrid_conn, &error, NULL);
				RETURN_FALSE;
			}
    
            if ((cubrid_retval = cci_end_tran(cubrid_conn, CCI_TRAN_COMMIT, &error)) < 0) {
                handle_error(cubrid_retval, &error, NULL);
                RETURN_FALSE;
            }
    
            connect = new_cubrid_connect(1);
            if (!connect) RETURN_FALSE;
            connect->handle = cubrid_conn;
    
            Z_TYPE(new_le) = le_pconnect;
            new_le.ptr = connect;
            if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_details_length + 1, (void *) &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
                free(connect);
                RETURN_FALSE;
            }
        } else { /* The link is in our list of persistent connections */
    
            if (Z_TYPE_P(le) != le_pconnect) {
                RETURN_FALSE;
            }
    
            connect = (T_CUBRID_CONNECT *) le->ptr;
    
            if (!check_connect_alive(connect)) {
				if ((cubrid_conn = cci_connect_with_url_ex(connect_url, userid, passwd, &error)) < 0) {
                    php_error_docref(NULL TSRMLS_CC, E_WARNING, "Link to server lost, unable to reconnect");
                    zend_hash_del(&EG(persistent_list), hashed_details, hashed_details_length+1);
                    RETURN_FALSE;
                }
    
                connect->handle = cubrid_conn;
            }
    
            if ((cubrid_retval = cci_end_tran(connect->handle, CCI_TRAN_COMMIT, &error)) < 0) {
                handle_error(cubrid_retval, &error, NULL);
                free(connect);
                RETURN_FALSE;
            }
        }
    
        CUBRID_G(last_request_id) = -1;
        
        ZEND_REGISTER_RESOURCE(return_value, connect, le_pconnect);
   
    } else { /* non persistent */

        zend_rsrc_list_entry *index_ptr, new_index_ptr;
    
        if (!new_link && zend_hash_find(&EG(regular_list), hashed_details, hashed_details_length+1, (void **) &index_ptr) == SUCCESS) {
            int type;
            long link;
            void *ptr;
    
            if (Z_TYPE_P(index_ptr) != le_index_ptr) {
                RETURN_FALSE;
            }
    
            link = (long) index_ptr->ptr;
            ptr = zend_list_find(link, &type);
            if (ptr && (type == le_connect || type == le_pconnect)) {
                zend_list_addref(link);
                Z_LVAL_P(return_value) = link;
                php_cubrid_set_default_conn(link TSRMLS_CC);
                Z_TYPE_P(return_value) = IS_RESOURCE;
                return;
            } else {
                zend_hash_del(&EG(regular_list), hashed_details, hashed_details_length+1);
            }
        }

		if ((cubrid_conn = cci_connect_with_url_ex(connect_url, userid, passwd, &error)) < 0) {
			handle_error(cubrid_conn, &error, NULL);
			RETURN_FALSE;
		}
    
        CUBRID_G(last_request_id) = -1;
    
        if ((cubrid_retval = cci_end_tran(cubrid_conn, CCI_TRAN_COMMIT, &error)) < 0) {
    	handle_error(cubrid_retval, &error, NULL);
    	cci_disconnect(cubrid_conn, &error);
    	RETURN_FALSE;
        }
    
        connect = new_cubrid_connect(0);
        if (!connect) RETURN_FALSE;
        connect->handle = cubrid_conn;
        
        ZEND_REGISTER_RESOURCE(return_value, connect, le_connect);
    
        new_index_ptr.ptr = (void *) Z_LVAL_P(return_value);
        Z_TYPE(new_index_ptr) = le_index_ptr;
        if (zend_hash_update(&EG(regular_list), hashed_details, hashed_details_length+1, (void *)&new_index_ptr, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
            RETURN_FALSE;
        }
    }

    php_cubrid_set_default_conn(Z_LVAL_P(return_value) TSRMLS_CC);
}

ZEND_FUNCTION(cubrid_pconnect)
{
    php_cubrid_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}

ZEND_FUNCTION(cubrid_connect)
{
    php_cubrid_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}

static void php_cubrid_do_connect_with_url(INTERNAL_FUNCTION_PARAMETERS, int persistent)
{
    char *url = NULL, *userid = NULL, *passwd = NULL;
    int url_len, userid_len, passwd_len;
    char buf[4096] = { '\0' };
    char hashed_details[4096] = { '\0' };
    int hashed_details_length;

    int cubrid_conn, cubrid_retval = 0;

    T_CUBRID_CONNECT *connect = NULL;
    T_CCI_ERROR error;

    zend_bool new_link = 0;

    init_error();

    if (zend_parse_parameters (ZEND_NUM_ARGS() TSRMLS_CC, "s|ssb", 
		&url, &url_len, &userid, &userid_len, &passwd, &passwd_len, &new_link) == FAILURE) {
	return;
    }

    if (strncasecmp (url, "cci:", 4) != 0) {
        snprintf (buf, sizeof(buf), "cci:%s", url);
    }
    else {
        strncpy (buf, url, sizeof(buf));
    }

    if (!userid) {
        userid = (char *) "";
    }

    if (!passwd) {
	passwd = (char *) "";
    }

    snprintf(hashed_details, sizeof(hashed_details), "%s:%s:%s", buf, userid, passwd);
    hashed_details_length = strlen(hashed_details);

    if (persistent) {
        zend_rsrc_list_entry *le;

        /* try to find if we already have this link in our persistent list */
        if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_length + 1, (void **) &le) == FAILURE) { /* we don't */
            zend_rsrc_list_entry new_le;
   
            if ((cubrid_conn = cci_connect_with_url_ex(buf, userid, passwd, &error)) < 0) {
                handle_error(cubrid_conn, &error, NULL);
                RETURN_FALSE;
            }
    
            if ((cubrid_retval = cci_end_tran(cubrid_conn, CCI_TRAN_COMMIT, &error)) < 0) {
                handle_error(cubrid_retval, &error, NULL);
                cci_disconnect(cubrid_conn, &error);
                RETURN_FALSE;
            }
    
            connect = new_cubrid_connect(1);
            if (!connect) RETURN_FALSE;
            connect->handle = cubrid_conn;
    
            Z_TYPE(new_le) = le_pconnect;
            new_le.ptr = connect;
            if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_details_length + 1, (void *) &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
                free(connect);
                RETURN_FALSE;
            }
    
        } else {
    
            if (Z_TYPE_P(le) != le_pconnect) {
                RETURN_FALSE;
            }
    
            connect = (T_CUBRID_CONNECT *) le->ptr;
    
            if (!check_connect_alive(connect)) {
                if ((cubrid_conn = cci_connect_with_url_ex(buf, userid, passwd, &error)) < 0) {
                    php_error_docref(NULL TSRMLS_CC, E_WARNING, "Link to server lost, unable to reconnect");
                    zend_hash_del(&EG(persistent_list), hashed_details, hashed_details_length+1);
                    RETURN_FALSE;
                }
    
                connect->handle = cubrid_conn;
            }
    
            if ((cubrid_retval = cci_end_tran(connect->handle, CCI_TRAN_COMMIT, &error)) < 0) {
                handle_error(cubrid_retval, &error, NULL);
                free(connect);
                RETURN_FALSE;
            }
        }
    
        CUBRID_G(last_request_id) = -1;
    
        ZEND_REGISTER_RESOURCE(return_value, connect, le_pconnect);

    } else { /* non persistent */

        zend_rsrc_list_entry *index_ptr, new_index_ptr;
    
        if (!new_link && zend_hash_find(&EG(regular_list), hashed_details, hashed_details_length + 1, (void **) &index_ptr) == SUCCESS) {
            int type;
            long link;
            void *ptr;
    
            if (Z_TYPE_P(index_ptr) != le_index_ptr) {
                RETURN_FALSE;
            }
    
            link = (long) index_ptr->ptr;
            ptr = zend_list_find(link, &type);
            if (ptr && (type == le_connect || type == le_pconnect)) {
                zend_list_addref(link);
                Z_LVAL_P(return_value) = link;
                php_cubrid_set_default_conn(link TSRMLS_CC);
                Z_TYPE_P(return_value) = IS_RESOURCE;
                return;
            } else {
                zend_hash_del(&EG(regular_list), hashed_details, hashed_details_length+1);
            }
        }
    
        if ((cubrid_conn = cci_connect_with_url_ex(buf, userid, passwd, &error)) < 0) {
    	handle_error(cubrid_conn, &error, NULL);
    	RETURN_FALSE;
        }
    
        CUBRID_G(last_request_id) = -1;
    
        if ((cubrid_retval = cci_end_tran(cubrid_conn, CCI_TRAN_COMMIT, &error)) < 0) {
    	handle_error(cubrid_retval, &error, NULL);
    	cci_disconnect(cubrid_conn, &error);
    	RETURN_FALSE;
        }
    
        connect = new_cubrid_connect(0);
        if (!connect) RETURN_FALSE;
        connect->handle = cubrid_conn;
    
        ZEND_REGISTER_RESOURCE(return_value, connect, le_connect);
    
        new_index_ptr.ptr = (void *)Z_LVAL_P(return_value);
        Z_TYPE(new_index_ptr) = le_index_ptr;
        if (zend_hash_update(&EG(regular_list), hashed_details, hashed_details_length + 1, (void *)&new_index_ptr, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
            RETURN_FALSE;
        }
    }

    php_cubrid_set_default_conn(Z_LVAL_P(return_value) TSRMLS_CC);
}

ZEND_FUNCTION(cubrid_pconnect_with_url)
{
    php_cubrid_do_connect_with_url(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}

ZEND_FUNCTION(cubrid_connect_with_url)
{
    php_cubrid_do_connect_with_url(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}

ZEND_FUNCTION(cubrid_close)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect = NULL;
    
    int res_id = -1;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
	return;
    }

    if (conn_id) {
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
        if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE;
        }

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    res_id = conn_id ? Z_RESVAL_P(conn_id) : CUBRID_G(last_connect_id);
    zend_list_delete(res_id);

    /* On an explicit close of the default connection it had a refcount of 2,
     * so we need one more call */
    if (!conn_id || (conn_id && Z_RESVAL_P(conn_id) == CUBRID_G(last_connect_id))) {
        CUBRID_G(last_connect_id) = -1;
        CUBRID_G(last_request_id) = -1;

        if (conn_id) {
            zend_list_delete(res_id);
        }
    }
    
    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_prepare)
{
    zval *conn_id = NULL;
    char *query = NULL;
    long option = 0;
    int query_len;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;

    int cubrid_retval = 0, request_handle = -1;
    int i;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &conn_id, &query, &query_len, &option) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    request = new_cubrid_request();
    if (!request) {
        handle_error(CCI_ER_REQ_HANDLE, NULL, connect);
        RETURN_FALSE;
    }
    request->conn = connect;

    if ((cubrid_retval = cci_prepare(connect->handle, query, 
                    (char) ((option & CUBRID_INCLUDE_OID) ? CCI_PREPARE_INCLUDE_OID : 0), &error)) < 0) {
        close_cubrid_request_internal(request);
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    request_handle = cubrid_retval;

    request->handle = request_handle;
    request->bind_num = cci_get_bind_num(request_handle);

    if (request->bind_num > 0) {
        request->l_bind = (short *) safe_emalloc(request->bind_num, sizeof(short), 0);
        for (i = 0; i < request->bind_num; i++) {
            request->l_bind[i] = 0;
        }
    }

    request->l_prepare = 1;
    request->fetch_field_auto_index = 0;

    ZEND_REGISTER_RESOURCE(return_value, request, le_request);
    php_cubrid_set_default_req(Z_LVAL_P(return_value) TSRMLS_CC);
    register_cubrid_request(connect, request);
}
static char* cubrid_str2bit(char* str)
{
    int i=0,len=0,t=0;
    char* buf=NULL;
    int shift = 8;

    if(str == NULL)
        return NULL;
    len = strlen(str);

    if(0 == len%shift)
        t =1;

    buf = (char*)emalloc(len/shift+1+1);
    memset(buf,0,len/shift+1+1);

    for(i=0;i<len;i++)
    {
        if(str[len-i-1] == '1')
        {
            buf[len/shift - i/shift-t] |= (1<<(i%shift)); 
        }
        else if(str[len-i-1] == '0')
        {
        	//nothing
        }
        else
        {
            return NULL;
        }
    }
    return buf;
}

ZEND_FUNCTION(cubrid_bind)
{
    zval *req_id= NULL, *bind_value = NULL;
    char *bind_value_type = NULL;
    long bind_index = -1;
    int bind_value_type_len;

    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;

    T_CCI_U_TYPE u_type = -1;
    T_CCI_A_TYPE a_type = -1;

    char *value = NULL;
    long value_len = 0;

    T_CCI_BIT *bit_value = NULL;
    T_CCI_LOB lob = NULL;

    php_stream *stm = NULL;
    char* lobfile_name = NULL;
    char buf[CUBRID_LOB_READ_BUF_SIZE];
    php_cubrid_int64_t lob_start_pos = 0;
    size_t lob_read_size = 0;

    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz|s", 
                &req_id, &bind_index, &bind_value, &bind_value_type, &bind_value_type_len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (bind_index < 1 || bind_index > request->bind_num) {
	RETURN_FALSE;
    }

    if (!bind_value_type) {
	u_type = CCI_U_TYPE_STRING;
    } else {
	u_type = get_cubrid_u_type_by_name(bind_value_type);
	/* collection type should be made by cci_set_make before calling cci_bind_param */
	if (u_type == CCI_U_TYPE_SET || u_type == CCI_U_TYPE_MULTISET || u_type == CCI_U_TYPE_SEQUENCE) {
	    php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bind value type unknown : %s\n", bind_value_type);
	    RETURN_FALSE;
	}
       if(u_type == CCI_U_TYPE_ENUM)
       {
           u_type = CCI_U_TYPE_STRING;
       }
    }

    if (u_type == CCI_U_TYPE_NULL || Z_TYPE_P(bind_value) == IS_NULL) {
        cubrid_retval = cci_bind_param(request->handle, bind_index, CCI_A_TYPE_STR, NULL, u_type, 0);
    } else if (u_type == U_TYPE_UNKNOWN) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bind value type unknown : %s\n", bind_value_type);
        RETURN_FALSE;
    } else {
        if (u_type == CCI_U_TYPE_BLOB || u_type == CCI_U_TYPE_CLOB) {
            if (Z_TYPE_P(bind_value) == IS_RESOURCE) {
                php_stream_from_zval_no_verify(stm, &bind_value);
                if (!stm) {
                    php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expected a stream resource when param type is LOB\n");
                    RETURN_FALSE;
                }
            } else {
                /* file name */
                convert_to_string(bind_value);
                lobfile_name = Z_STRVAL_P(bind_value);

                if (!(stm = php_stream_open_wrapper(lobfile_name, "r", REPORT_ERRORS, NULL))) {
                    RETURN_FALSE;
                }
            }
        } else {
            convert_to_string(bind_value);
        }

        value = Z_STRVAL_P(bind_value);
        value_len = Z_STRLEN_P(bind_value);

        switch (u_type) {
        case CCI_U_TYPE_BLOB:
                a_type = CCI_A_TYPE_BLOB;
                break;
        case CCI_U_TYPE_CLOB:
                a_type = CCI_A_TYPE_CLOB;
                break;
        case CCI_U_TYPE_BIT:
        case CCI_U_TYPE_VARBIT:
                a_type = CCI_A_TYPE_BIT;
                break;
        default:
                a_type = CCI_A_TYPE_STR;
                break;
        }
        
        if (u_type == CCI_U_TYPE_BLOB || u_type == CCI_U_TYPE_CLOB) {
            if ((cubrid_retval = cubrid_lob_new(request->conn->handle, &lob, u_type, &error)) < 0) {
                handle_error(cubrid_retval, &error, request->conn);

                if (lobfile_name) {
                    php_stream_close(stm);
                }

                RETURN_FALSE; 
            }

            while (!php_stream_eof(stm)) { 
                lob_read_size = php_stream_read(stm, buf, CUBRID_LOB_READ_BUF_SIZE); 

                if ((cubrid_retval = cubrid_lob_write(request->conn->handle, lob, u_type, 
                                lob_start_pos, lob_read_size, buf, &error)) < 0) {
                    handle_error(cubrid_retval, &error, request->conn);
                    php_stream_close(stm);
                    
                    RETURN_FALSE; 
                }        

                lob_start_pos += lob_read_size;
            }
           
            if (lobfile_name) {
                php_stream_close(stm);
            }

            cubrid_retval = cci_bind_param(request->handle, bind_index, a_type, (void *) lob, u_type, CCI_BIND_PTR); 

            request->lob = new_cubrid_lob();
            if (!request->lob) {
                handle_error(CCI_ER_NO_MORE_MEMORY, NULL, request->conn);
                RETURN_FALSE;
            }
            request->lob->lob = lob;
            request->lob->type = u_type;
        } else if (u_type == CCI_U_TYPE_BIT) {
            bit_value = (T_CCI_BIT *) emalloc(sizeof(T_CCI_BIT));            
            bit_value->buf = cubrid_str2bit(value);

            if(bit_value->buf == NULL)
            {
                handle_error(CCI_ER_TYPE_CONVERSION, NULL, request->conn);
                RETURN_FALSE;             
            }
            bit_value->size = strlen(bit_value[0].buf ); 

            cubrid_retval = cci_bind_param(request->handle, bind_index, a_type, (void *) bit_value, u_type, 0);
            efree(bit_value->buf);
            efree(bit_value);
        } else {
            cubrid_retval = cci_bind_param(request->handle, bind_index, a_type, value, u_type, 0);
        }
    }

    if (cubrid_retval != 0 || !request->l_bind) {
	handle_error(cubrid_retval, NULL, request->conn);
	RETURN_FALSE;
    }

    request->l_bind[bind_index - 1] = 1;

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_batch_execute)
{
    char exec_flag = 0;
    int count = 0, i = 0, n_executed = 0, err_code = 0;
    T_CUBRID_CONNECT *connect = NULL;
    T_CCI_ERROR error;    
    T_CCI_QUERY_RESULT *result;
    zval *id = NULL, *param = NULL;
    zval **z_item;
    char** sql = NULL;
    
    init_error(); 
	if (zend_parse_parameters(2 TSRMLS_CC, "rz", &id, &param) == FAILURE) {
        handle_error(CUBRID_ER_INVALID_PARAM_TYPE, NULL, connect);
	    RETURN_FALSE;
	}
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    if(IS_ARRAY != Z_TYPE_P(param)|| NULL == connect){
        handle_error(CUBRID_ER_INVALID_PARAM, NULL, connect);
        RETURN_FALSE;
    }
    count= zend_hash_num_elements(Z_ARRVAL_P(param));
    sql = malloc(count * sizeof(void*));
    if(NULL == sql){
        handle_error(CUBRID_ER_INVALID_PARAM, NULL, connect);
        RETURN_FALSE;
    }
    for (i = 0; i < count; i ++) {
        zend_hash_get_current_data(Z_ARRVAL_P(param), (void**) &z_item);
        zend_hash_move_forward(Z_ARRVAL_P(param));
        convert_to_string_ex(z_item); 
        sql[i] = Z_STRVAL_PP(z_item);
    }
    n_executed = cci_execute_batch (connect->handle, count, sql, &result, &error);
    if (n_executed < 0){
        free(sql);
        handle_error(n_executed, &error, connect);
        RETURN_FALSE;
    }
    free(sql);

    array_init(return_value);
    for (i = 0; i < n_executed; ++i){
        zval *item;
        MAKE_STD_ZVAL(item);
        array_init(item);
        add_index_long(item, 0, result[i].err_no);
        if (NULL == result[i].err_msg)
            add_index_string(item, 1, "", 1);
        else
            add_index_string(item, 1, result[i].err_msg, 1);
        add_index_zval(return_value, i, item);
    }
    err_code = cci_query_result_free (result, n_executed);    
    if (err_code < 0)    
    {     
        handle_error(n_executed, &error, connect); 
        RETURN_FALSE;
    }    
    
}

ZEND_FUNCTION(cubrid_execute)
{
    zval *id = NULL, *param = NULL;
    char *sql_stmt = NULL;
    long option = 0;
    int sql_stmt_len;

    char exec_flag = 0;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;
    int exec_retval = 0;

    T_CCI_COL_INFO *res_col_info;
    T_CCI_CUBRID_STMT res_sql_type;
    int res_col_count = 0;

    int cubrid_retval = 0;
    int req_handle = 0;
    int l_prepare = 0;
    int i;
    int is_prepare_and_execute_mode = 0;

    init_error();

    switch (ZEND_NUM_ARGS()) {
    case 1:
	/* It must be req_id */
	if (zend_parse_parameters(1 TSRMLS_CC, "r", &id) == FAILURE) {
	    return;
	}

	ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &id, -1, "CUBRID-Request", le_request);

	break;
    case 2:
	/* Param may be conn_id + sql_stmt or req_id + option */
	if (zend_parse_parameters(2 TSRMLS_CC, "rz", &id, &param) == FAILURE) {
	    return;
	}

	switch (Z_TYPE_P(param)) {
	case IS_STRING:
	    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &id, -1, "CUBRID-Connect", le_connect, le_pconnect);
	    sql_stmt = Z_STRVAL_P(param);	
	    sql_stmt_len = Z_STRLEN_P(param);
            is_prepare_and_execute_mode = 1;

	    break;
	case IS_LONG:
	    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &id, -1, "CUBRID-Request", le_request);
	    option = Z_LVAL_P(param);	

	    break;
	default:
	    RETURN_FALSE;
	}

	break;
    case 3:
	/* It must be conn_id + sql_stmt + option */
	if (zend_parse_parameters(3 TSRMLS_CC, "rsl", 
		    &id, &sql_stmt, &sql_stmt_len, &option) == FAILURE) {
	    return;
	}

	ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &id, -1, "CUBRID-Connect", le_connect, le_pconnect);

	break;
    default:
        WRONG_PARAM_COUNT;
    }

    if (connect == NULL && request != NULL) {
        connect = request->conn;
        req_handle = request->handle;

        init_error_link(connect);

        if (!request->l_prepare) {
            handle_error(CCI_ER_REQ_HANDLE, NULL, connect);
            RETURN_FALSE;
        }

        l_prepare = request->l_prepare;

        if (request->bind_num > 0) {
	    for (i = 0; i < request->bind_num; i++) {
		if (!request->l_bind[i]) {
                    handle_error(CUBRID_ER_PARAM_UNBIND, NULL, connect);
		    RETURN_FALSE;
		}
	    }
	}
    } else if (connect != NULL && request == NULL) {
        init_error_link(connect);

        request = new_cubrid_request();
        if (!request) {
            handle_error(CCI_ER_REQ_HANDLE, NULL, connect);
            RETURN_FALSE;
        }
        request->conn = connect;

        if (!is_prepare_and_execute_mode) {
            if ((cubrid_retval = cci_prepare(connect->handle, sql_stmt,
                    (char)((option & CUBRID_INCLUDE_OID) ? CCI_PREPARE_INCLUDE_OID : 0), &error)) < 0) {
                goto ERR_CUBRID_EXECUTE;
            }
        } else {
            if ((cubrid_retval =
                        cci_prepare_and_execute(connect->handle, sql_stmt, 0,
                            &exec_retval, &error)) < 0) {
				if(cubrid_retval == CAS_ER_NOT_IMPLEMENTED) {
					if ((cubrid_retval = cci_prepare(connect->handle, sql_stmt, 0, &error)) < 0) {
						goto ERR_CUBRID_EXECUTE;
					}
					if ((exec_retval = cci_execute(cubrid_retval, 0, 0, &error)) < 0) {
						cubrid_retval = exec_retval;
						goto ERR_CUBRID_EXECUTE;
					}
				} else {
					goto ERR_CUBRID_EXECUTE;
				}
            }
        }

        req_handle = cubrid_retval;
        request->handle = req_handle;
        request->l_prepare = 1;
        request->fetch_field_auto_index = 0;

        if ((request->bind_num = cci_get_bind_num(req_handle)) > 0) {
            request->l_bind = (short *) safe_emalloc(request->bind_num, sizeof(short), 0);
            for (i = 0; i < request->bind_num; i++) {
                request->l_bind[i] = 0;
            }
        }
    }

    if (!is_prepare_and_execute_mode) {
        if (option & CUBRID_EXEC_QUERY_ALL) {
            exec_flag |= CCI_EXEC_QUERY_ALL;
        } else if (option & CUBRID_ASYNC) {
            exec_flag |= CCI_EXEC_ASYNC;
        }
    
        if ((exec_retval = cci_execute(req_handle, exec_flag, 0, &error)) < 0) {
            cubrid_retval = exec_retval;
            goto ERR_CUBRID_EXECUTE;
        }
    }
    
    res_col_info = cci_get_result_info(req_handle, &res_sql_type, &res_col_count);
    if (res_sql_type == CUBRID_STMT_SELECT && !res_col_info) {
        cubrid_retval = CUBRID_ER_CANNOT_GET_COLUMN_INFO;
        goto ERR_CUBRID_EXECUTE;
    }

    if (request->lob) {
        close_cubrid_lob_internal(request->lob);
        request->lob = NULL;
    }

    request->col_info = res_col_info;
    request->sql_type = res_sql_type;
    request->col_count = res_col_count;

    connect->sql_type = res_sql_type;

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
        request->row_count = exec_retval;
        if (cubrid_retval > 0 && request->field_lengths == NULL) {
            request->field_lengths = (int *) emalloc (sizeof(int) * res_col_count);
        }

        cubrid_retval = cci_cursor(req_handle, 1, CCI_CURSOR_CURRENT, &error);
        if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
            goto ERR_CUBRID_EXECUTE;
        } 
        
        break;
    case CUBRID_STMT_INSERT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        connect->affected_rows = exec_retval;
        break;
    case CUBRID_STMT_CALL:
        request->row_count = exec_retval;
        connect->affected_rows = exec_retval;
    default: 
        break;
    }

    if (!l_prepare) {
        ZEND_REGISTER_RESOURCE(return_value, request, le_request);
        php_cubrid_set_default_req(Z_LVAL_P(return_value) TSRMLS_CC);
        register_cubrid_request(connect, request);
        return;
    }

    RETURN_TRUE;

ERR_CUBRID_EXECUTE:
    if (!l_prepare) {
        close_cubrid_request_internal(request);
    }
    handle_error(cubrid_retval, &error, connect);
    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_next_result)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;

    T_CCI_COL_INFO *res_col_info;
    T_CCI_CUBRID_STMT res_sql_type;
    int res_col_count = 0;

    int cubrid_retval = 0;
    T_CCI_ERROR error;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);
   
    cubrid_retval = cci_next_result(request->handle, &error);
    if (cubrid_retval == CAS_ER_NO_MORE_RESULT_SET) {
        RETURN_FALSE;
    }

    if (cubrid_retval < 0) {
        handle_error(cubrid_retval, &error, request->conn);
        RETURN_FALSE;
    }

    if (request->field_lengths != NULL) {
        efree(request->field_lengths);
        request->field_lengths = NULL;
    }

    if (request->lob2_list != NULL) {
        int i;
        for (i = 0; i < request->col_count; i++) {
            if (request->lob2_list[i]) {
                request->lob2_list[i]->connect = NULL;
                request->lob2_list[i] = NULL;
            }
        }

        efree(request->lob2_list);
        request->lob2_list = NULL;
    }

    res_col_info = cci_get_result_info(request->handle, &res_sql_type, &res_col_count);
    if (res_sql_type == CUBRID_STMT_SELECT && !res_col_info) {
	RETURN_FALSE;
    }

    request->col_info = res_col_info;
    request->sql_type = res_sql_type;
    request->col_count = res_col_count;

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	request->row_count = cubrid_retval;
        request->field_lengths = (int *) emalloc (sizeof(int) * res_col_count); 
        break;
    case CUBRID_STMT_INSERT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        request->conn->affected_rows = cubrid_retval;
        break;
    case CUBRID_STMT_CALL:
        request->row_count = cubrid_retval;
    default:
        break;
    }

    cubrid_retval = cci_cursor(request->handle, 1, CCI_CURSOR_CURRENT, &error);
    if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
        handle_error(cubrid_retval, &error, request->conn);
        RETURN_FALSE;
    }

    request->fetch_field_auto_index = 0;

    request->conn->sql_type = request->sql_type;

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_affected_rows)
{
    zval *id = NULL;
    void *ptr = NULL;
    int type;
    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_REQUEST *request = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &id) == FAILURE) {
	return;
    }

    if (id) {
        ptr = (void *)zend_fetch_resource(&id TSRMLS_CC, -1, NULL, &type, 3, le_connect, le_pconnect, le_request);

        if (type == le_request) {
            request = (T_CUBRID_REQUEST *) ptr;
            connect = request->conn;

        } else if (type == le_connect || type == le_pconnect) {
            connect = (T_CUBRID_CONNECT *) ptr;

        } else {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "A invalid resource has been input.\n");
            RETURN_FALSE;
        }

    } else {
	if (CUBRID_G(last_connect_id) == -1) {
	  RETURN_FALSE;
	}
        
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    switch (connect->sql_type) {
    case CUBRID_STMT_INSERT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        RETURN_LONG(connect->affected_rows);
    default:
        handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, connect);
        RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_close_request)
{
    zval *req_id= NULL;
    T_CUBRID_REQUEST *request;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);
    zend_list_delete(Z_RESVAL_P(req_id));

    /* On an explicit close of the default request it had a refcount of 2,
     * so we need one more call */
    if (Z_RESVAL_P(req_id) == CUBRID_G(last_request_id)) {
        CUBRID_G(last_request_id) = -1;

        zend_list_delete(Z_RESVAL_P(req_id));
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_current_oid)
{
    zval *req_id= NULL;

    T_CUBRID_REQUEST *request;
    T_CCI_ERROR error;

    char oid_buf[1024];
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (request->sql_type != CUBRID_STMT_SELECT) {
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_FALSE;
    }

    if ((cubrid_retval = cci_fetch(request->handle, &error)) < 0) {
        handle_error(cubrid_retval, &error, request->conn);
        RETURN_FALSE;
    }

    if ((cubrid_retval = cci_get_cur_oid(request->handle, oid_buf)) < 0) {
        handle_error(cubrid_retval, NULL, request->conn);
        RETURN_FALSE;
    }

    RETURN_STRING(oid_buf, 1);
}

ZEND_FUNCTION(cubrid_column_types)
{
    zval *req_id= NULL;
    T_CUBRID_REQUEST *request;

    char full_type_name[128] = {'\0'};
    int i;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);
    
    array_init(return_value);

    for (i = 0; i < request->col_count; i++) {
	if (type2str(&request->col_info[i], full_type_name, sizeof(full_type_name)) < 0) {
	    handle_error(CCI_ER_TYPE_CONVERSION, NULL, request->conn);
            cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);
	    RETURN_FALSE;
	}

	add_index_stringl(return_value, i, full_type_name, strlen(full_type_name), 1);
    }

    return;
}

ZEND_FUNCTION(cubrid_column_names)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;
    char *column_name;

    int i;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);
    
    array_init(return_value);

    for (i = 0; i < request->col_count; i++) {
	column_name = CCI_GET_RESULT_INFO_NAME(request->col_info, i + 1);
	add_index_stringl(return_value, i, column_name, strlen(column_name), 1);
    }

    return;
}

ZEND_FUNCTION(cubrid_move_cursor)
{
    zval *req_id = NULL;
    long offset = 0, origin = CUBRID_CURSOR_CURRENT;

    T_CUBRID_REQUEST *request = NULL;

    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &req_id, &offset, &origin) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    cubrid_retval = cci_cursor(request->handle, offset, origin, &error);
    if (cubrid_retval < 0) {
	handle_error(cubrid_retval, &error, request->conn);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_num_rows)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_LONG(request->row_count);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_FALSE;
    }
}

ZEND_FUNCTION(cubrid_num_cols)
{
    zval *req_id;
    T_CUBRID_REQUEST *request = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);
    
    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_LONG(request->col_count);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_FALSE;
    }
}

ZEND_FUNCTION(cubrid_get)
{
    zval *conn_id = NULL, *attr_name = NULL;
    char *oid = NULL;
    int oid_len;
    int attr_count = -1;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;
    int i;

    zval **elem_buf = NULL;
    char **attr = NULL;
    int request_handle;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|z", &conn_id, &oid, &oid_len, &attr_name) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if (attr_name) {
	switch (Z_TYPE_P(attr_name)) {
	case IS_STRING:
	    attr_count = 1;
	    attr = (char **) safe_emalloc(attr_count + 1, sizeof(char *), 0);

	    convert_to_string_ex(&attr_name);

	    attr[0] = estrndup(Z_STRVAL_P(attr_name), Z_STRLEN_P(attr_name));
	    attr[1] = NULL;

	    break;
	case IS_ARRAY:
	    attr_count = zend_hash_num_elements(HASH_OF(attr_name));
	    attr = (char **) safe_emalloc(attr_count + 1, sizeof(char *), 0);

	    for (i = 0; i <= attr_count; i++) {
		attr[i] = NULL;
	    }

	    for (i = 0; i < attr_count; i++) {
		if (zend_hash_index_find(HASH_OF(attr_name), i, (void **) &elem_buf) == FAILURE) {
		    handle_error(CUBRID_ER_INVALID_PARAM, NULL, connect);
		    goto ERR_CUBRID_GET;
		}
		convert_to_string_ex(elem_buf);
		attr[i] = estrdup(Z_STRVAL_P(*elem_buf));
	    }
	    attr[i] = NULL;

	    break;
	default:
	    handle_error(CUBRID_ER_INVALID_PARAM, NULL, connect);
	    RETURN_FALSE;
	}
    }

    cubrid_retval = cci_oid_get(connect->handle, oid, attr, &error);
    if (cubrid_retval < 0) {
	handle_error(cubrid_retval, &error, connect);
	goto ERR_CUBRID_GET;
    }
    request_handle = cubrid_retval;

    /* free memory before return */
    for (i = 0; i < attr_count; i++) {
 	if (attr[i]) {
	    efree(attr[i]);   
	}
    }

    if (attr) {
	efree(attr);
    }

    if (attr_name && Z_TYPE_P(attr_name) == IS_STRING) {
	char *result;
	int ind;

	cubrid_retval = cci_get_data(request_handle, 1, CCI_A_TYPE_STR, &result, &ind);
	if (cubrid_retval < 0) {
	    handle_error(cubrid_retval, &error, connect);
	    RETURN_FALSE;
	}

	if (ind < 0) {
	    RETURN_FALSE;
	} else {
	    RETURN_STRINGL(result, ind, 1);
	}
    } else {
	if ((cubrid_retval = fetch_a_row(return_value, connect, request_handle, NULL, CUBRID_ASSOC TSRMLS_CC)) != SUCCESS) {
	    handle_error(cubrid_retval, NULL, connect);
	    RETURN_FALSE;
	}
    }

    return;

ERR_CUBRID_GET:

    for (i = 0; i < attr_count; i++) {
 	if (attr[i]) {
	    efree(attr[i]);   
	}
    }

    if (attr) {
	efree(attr);
    }
    
    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_put)
{
    zval *conn_id = NULL, *attr_value = NULL;
    char *oid = NULL, *attr = NULL;
    int oid_len, attr_len;

    char **attr_name = NULL;
    int attr_count = 0;
    int *attr_type = NULL;

    T_CUBRID_CONNECT *connect;
    T_CCI_SET temp_set = NULL;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    void **value = NULL;
    char *key = NULL;
    ulong index;
    zval **data = NULL;
    int i;

    init_error();

    switch (ZEND_NUM_ARGS()) {
    case 3:
	if (zend_parse_parameters(3 TSRMLS_CC, "rsa", &conn_id, &oid, &oid_len, &attr_value) == FAILURE) {
	    return;
	}

	ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

	attr_count = zend_hash_num_elements(HASH_OF(attr_value));
	zend_hash_internal_pointer_reset(HASH_OF(attr_value));

	attr_name = (char **) safe_emalloc(attr_count + 1, sizeof(char *), 0);
	value = safe_emalloc(attr_count + 1, sizeof(char *), 0);
	attr_type = (int *) safe_emalloc(attr_count + 1, sizeof(int), 0);

	if (attr_count > 0) {
	    for (i = 0; i < attr_count; i++) {
		if (zend_hash_get_current_key(HASH_OF(attr_value), &key, &index, 1) == HASH_KEY_NON_EXISTANT) {
		    break;
		}

		attr_name[i] = (char *) safe_emalloc(strlen(key) + 1, sizeof(char), 0);
		strlcpy(attr_name[i], key, strlen(key) + 1);
		value[i] = NULL;
		attr_type[i] = 0;

		efree(key);

		zend_hash_get_current_data(HASH_OF(attr_value), (void **) &data);
		switch (Z_TYPE_PP(data)) {
		case IS_NULL:
		    value[i] = NULL;

		    break;
		case IS_LONG:
		case IS_DOUBLE:
		    convert_to_string_ex(data);
		case IS_STRING:
		    value[i] = (char *) safe_emalloc(Z_STRLEN_PP(data) + 1, sizeof(char), 0);
		    strlcpy(value[i], Z_STRVAL_PP(data), Z_STRLEN_PP(data) + 1);
		    attr_type[i] = CCI_A_TYPE_STR;

		    break;
		case IS_ARRAY:
		    cubrid_retval = cubrid_make_set(HASH_OF(*data), &temp_set);
		    if (cubrid_retval < 0) {
			handle_error(cubrid_retval, NULL, connect);
			goto ERR_CUBRID_PUT;
		    }

		    value[i] = temp_set;
		    attr_type[i] = CCI_A_TYPE_SET;

		    break;
		case IS_OBJECT:
		case IS_BOOL:
		case IS_RESOURCE:
		case IS_CONSTANT:
		    cubrid_retval = -1;
		    handle_error(CUBRID_ER_NOT_SUPPORTED_TYPE, NULL, connect);
		    goto ERR_CUBRID_PUT;
		}

		zend_hash_move_forward(HASH_OF(attr_value));
	    }

	    attr_name[attr_count] = NULL;
	    value[attr_count] = NULL;	
	}

	break;
    case 4:
	if (zend_parse_parameters(4 TSRMLS_CC, "rssz", 
		    &conn_id, &oid, &oid_len, &attr, &attr_len, &attr_value) == FAILURE) {
	    return;
	}

	ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

	attr_count = 1;

	attr_name = (char **) safe_emalloc(attr_count + 1, sizeof(char *), 0);
	value = safe_emalloc(attr_count + 1, sizeof(char *), 0);
	attr_type = safe_emalloc(attr_count + 1, sizeof(int), 0);

	attr_name[0] = (char *) safe_emalloc (attr_len + 1, sizeof(char), 0);
	strlcpy(attr_name[0], attr, attr_len + 1);
	attr_name[1] = NULL;

	value[0] = NULL;
	attr_type[0] = 0;

	switch (Z_TYPE_P(attr_value)) {
	case IS_NULL:
	    value[0] = NULL;
	    
	    break;
	case IS_LONG:
	case IS_DOUBLE:
	    convert_to_string_ex(&attr_value);
	case IS_STRING:
	    value[0] = (char *) safe_emalloc(Z_STRLEN_P(attr_value) + 1, sizeof(char), 0);
	    strlcpy(value[0], Z_STRVAL_P(attr_value), Z_STRLEN_P(attr_value) + 1);
	    attr_type[0] = CCI_A_TYPE_STR;

	    break;
	case IS_ARRAY:
	    cubrid_retval = cubrid_make_set(HASH_OF(attr_value), &temp_set);
	    if (cubrid_retval < 0) {
		handle_error(cubrid_retval, NULL, connect);
		goto ERR_CUBRID_PUT;
	    }

	    value[0] = temp_set;
	    attr_type[0] = CCI_A_TYPE_SET;

	    break;
	case IS_OBJECT:
	case IS_BOOL:
	case IS_RESOURCE:
	case IS_CONSTANT:
	    cubrid_retval = -1;
	    handle_error(CUBRID_ER_NOT_SUPPORTED_TYPE, NULL, connect);
	    goto ERR_CUBRID_PUT;
	}
	value[1] = NULL;

	break;
    default:
	WRONG_PARAM_COUNT;
    }

    cubrid_retval = cci_oid_put2(connect->handle, oid, attr_name, value, attr_type, &error);
    if (cubrid_retval < 0) {
	handle_error(cubrid_retval, &error, connect);
	goto ERR_CUBRID_PUT;
    }

ERR_CUBRID_PUT:

    if (attr_name) {
	for (i = 0; i < attr_count; i++) {
	    if (attr_name[i])
		efree(attr_name[i]);
	}
	efree(attr_name);
    }

    if (value) {
	for (i = 0; i < attr_count; i++) {
	    switch (attr_type[i]) {
	    case CCI_A_TYPE_SET:
		cci_set_free(value[i]);
		break;
	    default:
		if (value[i]) {
		    efree(value[i]);
		}
		break;
	    }
	}
	efree(value);
    }

    if (attr_type) {
	efree(attr_type);
    }

    if (cubrid_retval < 0) {
	RETURN_FALSE;
    } else {
	RETURN_TRUE;
    }
}

ZEND_FUNCTION(cubrid_drop)
{
    zval *conn_id = NULL;
    char *oid = NULL;
    int oid_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &oid, &oid_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_oid(connect->handle, CCI_OID_DROP, oid, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE; 
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_is_instance)
{
    zval *conn_id = NULL;
    char *oid = NULL;
    int oid_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &oid, &oid_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_oid(connect->handle, CCI_OID_IS_INSTANCE, oid, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_LONG(-1);
    }

    RETURN_LONG(cubrid_retval);
}

ZEND_FUNCTION(cubrid_lock_read)
{
    zval *conn_id = NULL;
    char *oid = NULL;
    int oid_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &oid, &oid_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_oid(connect->handle, CCI_OID_LOCK_READ, oid, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE; 
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lock_write)
{
    zval *conn_id = NULL;
    char *oid = NULL;
    int oid_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &oid, &oid_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_oid(connect->handle, CCI_OID_LOCK_WRITE, oid, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE; 
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_get_class_name)
{
    zval *conn_id = NULL;
    char *oid = NULL;
    int oid_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;
    char out_buf[1024];

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &oid, &oid_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_oid_get_class_name(connect->handle, oid, out_buf, 1024, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_STRING(out_buf, 1);
}

ZEND_FUNCTION(cubrid_schema)
{
    zval *conn_id = NULL;
    char *class_name = NULL, *attr_name = NULL;
    long schema_type;
    int class_name_len, attr_name_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    int flag = 0;
    int cubrid_retval = 0;
    int request_handle;
    int i = 0;
    zval *temp_element = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|ss", 
		&conn_id, &schema_type, &class_name, &class_name_len, &attr_name, &attr_name_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    switch (schema_type) {
    case CUBRID_SCH_CLASS:
    case CUBRID_SCH_VCLASS:
    case CUBRID_SCH_TRIGGER:
	flag = CCI_CLASS_NAME_PATTERN_MATCH;
	break;
    case CUBRID_SCH_ATTRIBUTE:
    case CUBRID_SCH_CLASS_ATTRIBUTE:
	flag = CCI_ATTR_NAME_PATTERN_MATCH;
	break;
    default:
	flag = 0;
	break;
    }

    if ((cubrid_retval = cci_schema_info(connect->handle, 
		    schema_type, class_name, attr_name, (char) flag, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    request_handle = cubrid_retval;

    array_init(return_value);

    for (i = 0; ; i++) {
	cubrid_retval = cci_cursor(request_handle, 1, CCI_CURSOR_CURRENT, &error);
	if (cubrid_retval == CCI_ER_NO_MORE_DATA) {
	    break;
	}

	if (cubrid_retval < 0) {
	    handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_SCHEMA;
	}

	if ((cubrid_retval = cci_fetch(request_handle, &error)) < 0) {
	    handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_SCHEMA;
	}

	MAKE_STD_ZVAL(temp_element);
	if ((cubrid_retval = fetch_a_row(temp_element, connect, request_handle, NULL, CUBRID_ASSOC TSRMLS_CC)) != SUCCESS) {
	    handle_error(cubrid_retval, NULL, connect);
	    FREE_ZVAL(temp_element);
            goto ERR_CUBRID_SCHEMA;
	}

	zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &temp_element, sizeof(zval *), NULL);
    }

    cci_close_req_handle(request_handle);

    return;

ERR_CUBRID_SCHEMA:

    cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);
    cci_close_req_handle(request_handle);

    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_col_size)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL;
    int oid_len, attr_name_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;
    int col_size = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);
    
    if ((cubrid_retval = cci_col_size(connect->handle, oid, attr_name, &col_size, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_LONG(col_size);
}

ZEND_FUNCTION(cubrid_col_get)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL;
    int oid_len, attr_name_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    char *res_buf;
    int ind;
    int col_size;
    int col_type;
    int request_handle;
    int i = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_get(connect->handle, oid, attr_name, &col_size, &col_type, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    request_handle = cubrid_retval;

    array_init(return_value);

    for (i = 0; ;i++) {
	cubrid_retval = cci_cursor(request_handle, 1, CCI_CURSOR_CURRENT, &error);
	if (cubrid_retval == CCI_ER_NO_MORE_DATA) {
	    break;
	}

	if (cubrid_retval < 0) {
	    handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_COL_GET;
	}

	if ((cubrid_retval = cci_fetch(request_handle, &error)) < 0) {
	    handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_COL_GET;
	}

	if ((cubrid_retval = cci_get_data(request_handle, 1, CCI_A_TYPE_STR, &res_buf, &ind)) < 0) {
	    handle_error(cubrid_retval, NULL, connect);
            goto ERR_CUBRID_COL_GET;
	}

	if (ind < 0) {
	    add_index_unset(return_value, i);
	} else {
	    add_index_stringl(return_value, i, res_buf, ind, 1);
	}
    }

    cci_close_req_handle(request_handle);

    return;

ERR_CUBRID_COL_GET:

    cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);
    cci_close_req_handle(request_handle);

    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_set_add)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL, *set_element = NULL;
    int oid_len, attr_name_len, set_element_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len, &set_element, &set_element_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_set_add(connect->handle, oid, attr_name, set_element, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_set_drop)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL, *set_element = NULL;
    int oid_len, attr_name_len, set_element_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsss", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len, &set_element, &set_element_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_set_drop(connect->handle, oid, attr_name, set_element, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_seq_insert)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL, *seq_element = NULL;
    long index = -1;
    int oid_len, attr_name_len, seq_element_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssls", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len, &index, 
		&seq_element, &seq_element_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_seq_insert(connect->handle, oid, attr_name, index, seq_element, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_seq_put)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL, *seq_element = NULL;
    long index = -1;
    int oid_len, attr_name_len, seq_element_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssls", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len, &index, 
		&seq_element, &seq_element_len) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_seq_put(connect->handle, oid, attr_name, index, seq_element, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_seq_drop)
{
    zval *conn_id = NULL;
    char *oid = NULL, *attr_name = NULL;
    long index = -1;
    int oid_len, attr_name_len;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rssl", 
		&conn_id, &oid, &oid_len, &attr_name, &attr_name_len, &index) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_col_seq_drop(connect->handle, oid, attr_name, index, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_get_autocommit)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    CCI_AUTOCOMMIT_MODE mode;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((mode = cci_get_autocommit(connect->handle)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        return; 
    }

    if (mode == CCI_AUTOCOMMIT_TRUE) {
	RETURN_TRUE;
    }

    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_set_autocommit)
{
    zval *conn_id = NULL;
    zend_bool param = FALSE;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    CCI_AUTOCOMMIT_MODE mode;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rb", &conn_id, &param) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    mode = param ? CCI_AUTOCOMMIT_TRUE : CCI_AUTOCOMMIT_FALSE;
    if ((cubrid_retval = cci_set_autocommit(connect->handle, mode)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }
	
    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_commit)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_end_tran(connect->handle, CCI_TRAN_COMMIT, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_rollback)
{
    zval *conn_id = NULL;
    
    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if ((cubrid_retval = cci_end_tran(connect->handle, CCI_TRAN_ROLLBACK, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_error_msg)
{
    if (zend_parse_parameters_none() == FAILURE) {
	return;
    }

    RETURN_STRING(CUBRID_G(recent_error).msg, 1);
}

ZEND_FUNCTION(cubrid_error_code)
{
    if (zend_parse_parameters_none() == FAILURE) {
	return;
    }

    RETURN_LONG(CUBRID_G(recent_error).code);
}

ZEND_FUNCTION(cubrid_error_code_facility)
{
    if (zend_parse_parameters_none() == FAILURE) {
	return;
    }

    RETURN_LONG(CUBRID_G(recent_error).facility);
}

ZEND_FUNCTION(cubrid_error)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
	return;
    }
    
    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            if (CUBRID_G(recent_error).msg[0] != 0) {
                RETURN_STRING(CUBRID_G(recent_error).msg, 1);
            } else {
                RETURN_FALSE;
            }
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    RETURN_STRING(connect->recent_error.msg, 1);
}

ZEND_FUNCTION(cubrid_errno)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
	return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            if (CUBRID_G(recent_error).code != 0) {
                RETURN_LONG(CUBRID_G(recent_error).code);
            } else {
                RETURN_FALSE;
            }
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    RETURN_LONG(connect->recent_error.code);
}

ZEND_FUNCTION(cubrid_field_name)
{
    zval *req_id = NULL;
    long offset = -1;

    T_CUBRID_REQUEST *request;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset >= request->col_count) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_STRING(request->col_info[offset].col_name, 1);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_field_table)
{
    zval *req_id = NULL;
    long offset = -1;

    T_CUBRID_REQUEST *request;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset >= request->col_count) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_STRING(request->col_info[offset].class_name, 1);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_field_type)
{
    zval *req_id = NULL;
    long offset = -1;
    T_CUBRID_REQUEST *request;
    char string_type[128] = {'\0'};

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset >= request->col_count) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	type2str(&request->col_info[offset], string_type, sizeof(string_type));
	RETURN_STRING(string_type, 1);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_field_flags)
{
    zval *req_id = NULL; 
    long offset = -1;
    T_CUBRID_REQUEST *request;
    int n;
    char sz[1024] = {'\0'};

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset >= request->col_count) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    if (request->col_info[offset].is_non_null) {
	strcat(sz, "not_null ");
    }

    if (request->col_info[offset].is_primary_key) {
	strcat(sz, "primary_key ");
    }

    if (request->col_info[offset].is_unique_key) {
	strcat(sz, "unique_key ");
    }

    if (request->col_info[offset].is_foreign_key) {
	strcat(sz, "foreign_key ");
    }

    if (request->col_info[offset].is_auto_increment) {
	strcat(sz, "auto_increment ");
    }

    if (request->col_info[offset].is_shared) {
	strcat(sz, "shared ");
    }

    if (request->col_info[offset].is_reverse_index) {
	strcat(sz, "reverse_index ");
    }

    if (request->col_info[offset].is_reverse_unique) {
	strcat(sz, "reverse_unique ");
    }

    if (request->col_info[offset].ext_type == CCI_U_TYPE_TIMESTAMP) {
	strcat(sz, "timestamp ");
    }

    n = strlen(sz);
    if (n > 0 && sz[n - 1] == ' ') {
	sz[n - 1] = 0;
    }

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_STRING(sz, 1);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_data_seek)
{
    zval *req_id = NULL;
    long offset = -1;

    T_CUBRID_REQUEST *request;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (request->row_count == 0) {
	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of rows is NULL.\n");
	RETURN_FALSE;
    }

    if ((cubrid_retval = cci_cursor(request->handle, offset + 1, CUBRID_CURSOR_FIRST, &error)) < 0) {
	handle_error(cubrid_retval, &error, request->conn);
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_fetch)
{
    php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
}

ZEND_FUNCTION(cubrid_fetch_array)
{
    php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, 0);
}

ZEND_FUNCTION(cubrid_fetch_assoc)
{
    php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, CUBRID_ASSOC, 0);
}

ZEND_FUNCTION(cubrid_fetch_row)
{
    php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, CUBRID_NUM, 0);
}

ZEND_FUNCTION(cubrid_fetch_object)
{
    php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, CUBRID_BOTH | CUBRID_OBJECT, 1);
}

ZEND_FUNCTION(cubrid_fetch_field)
{
    zval *req_id = NULL;
    long offset = 0;

    T_CUBRID_REQUEST *request = NULL;

    zend_bool is_numeric = 0, is_blob = 0;
    int max_length = 0;

    int res = 0;
    char *buffer = NULL;
    char string_type[128];

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (ZEND_NUM_ARGS() == 1) {
	offset = request->fetch_field_auto_index++;

        if (offset >= request->col_count) {
            RETURN_FALSE;
        }

    } else if (ZEND_NUM_ARGS() == 2) {
	request->fetch_field_auto_index = offset + 1;
    
        if (offset < 0 || offset >= request->col_count) {
    	    handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
    	    RETURN_FALSE;
        }
    }

    array_init(return_value);

    is_numeric = numeric_type(request->col_info[offset].ext_type);
    max_length = 0;
    is_blob = (request->col_info[offset].ext_type == CCI_U_TYPE_BLOB)?1:0;

    add_assoc_string(return_value, "name", request->col_info[offset].col_name, 1);
    add_assoc_string(return_value, "table", request->col_info[offset].class_name, 1);

    if (is_numeric) {
        if (request->col_info[offset].default_value[0] == '\0') {
            add_assoc_null(return_value, "def");
        } else {
            add_assoc_string(return_value, "def", request->col_info[offset].default_value, 1);
        }
    } else {
        add_assoc_string(return_value, "def", request->col_info[offset].default_value, 1);
    }

    add_assoc_long(return_value, "max_length", max_length);
    add_assoc_long(return_value, "not_null", request->col_info[offset].is_non_null);
    add_assoc_long(return_value, "primary_key", request->col_info[offset].is_primary_key);
    add_assoc_long(return_value, "unique_key", request->col_info[offset].is_unique_key);
    add_assoc_long(return_value, "multiple_key", !request->col_info[offset].is_unique_key);
    add_assoc_long(return_value, "numeric", is_numeric);
    add_assoc_long(return_value, "blob", is_blob);

    type2str(&request->col_info[offset], string_type, sizeof(string_type));
    add_assoc_string(return_value, "type", string_type, 1);

    add_assoc_long(return_value, "unsigned", 0);
    add_assoc_long(return_value, "zerofill", 0);

    if (return_value->type == IS_ARRAY) {
	convert_to_object(return_value);
    }

    return;
}

ZEND_FUNCTION(cubrid_num_fields)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
	RETURN_LONG(request->col_count);
    default:
	handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, request->conn);
	RETURN_LONG(-1);
    }
}

ZEND_FUNCTION(cubrid_free_result)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	RETURN_FALSE;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if ((cubrid_retval = cci_fetch_buffer_clear(request->handle)) < 0) {
	handle_error(cubrid_retval, NULL, request->conn); 
	RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_fetch_lengths)
{
    zval *req_id = NULL;

    T_CUBRID_REQUEST *request;
    int col;
    long len = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (request->field_lengths == NULL) {
        handle_error (CUBRID_ER_CANNOT_GET_COLUMN_INFO, NULL, request->conn);
        RETURN_FALSE;
    }

    array_init(return_value);

    for (col = 0; col < request->col_count; col++) {
	add_index_long(return_value, col, request->field_lengths[col]);
    }

    return;
}

ZEND_FUNCTION(cubrid_field_seek)
{
    zval *req_id = NULL;
    long offset = 0;
    T_CUBRID_REQUEST *request = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset > request->col_count - 1) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    /* Set the offset which will be used by cubrid_fetch_field() */
    request->fetch_field_auto_index = offset;

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_field_len)
{
    zval *req_id = NULL;
    long offset = 0;

    T_CUBRID_REQUEST *request;
    long len = 0;
    T_CCI_U_TYPE type;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &offset) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if (offset < 0 || offset > request->col_count - 1) {
	handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	RETURN_FALSE;
    }

    type = CCI_GET_COLLECTION_DOMAIN(CCI_GET_RESULT_INFO_TYPE(request->col_info, offset + 1));
    if ((len = get_cubrid_u_type_len(type)) == -1) {
	len = CCI_GET_RESULT_INFO_PRECISION(request->col_info, offset + 1); 
	if (type == CCI_U_TYPE_NUMERIC) {
	    len += 2; /* "," + "-" */
	}
    }

    if (CCI_IS_COLLECTION_TYPE(CCI_GET_RESULT_INFO_TYPE(request->col_info, offset + 1))) {
	len = MAX_LEN_SET;
    }

    RETURN_LONG(len);
}

ZEND_FUNCTION(cubrid_result)
{
    zval *req_id = NULL;
    long row_offset = 0;
    zval *column = NULL;

    long col_offset = 0;
    char *col_name = NULL;
    long col_name_len = 0;

    int cubrid_retval = 0;
    int i;

    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;

    char *res_buf = NULL;
    int ind = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &req_id, &row_offset, &column) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if ((cubrid_retval = cci_cursor(request->handle, row_offset + 1, 
		    CCI_CURSOR_FIRST, &error)) == CCI_ER_NO_MORE_DATA) {
	RETURN_FALSE;
    } else if (cubrid_retval < 0) {
        handle_error(cubrid_retval, &error, request->conn);
        RETURN_FALSE;
    }

    if (column) {
	switch (Z_TYPE_P(column)) {
	case IS_STRING: {
            char *table_name = NULL, *field_name = NULL, *tmp = NULL;

	    convert_to_string_ex(&column);
	    col_name = Z_STRVAL_P(column);
	    col_name_len = Z_STRLEN_P(column);

            tmp = strchr(col_name, '.');

	    for (i = 0; i < request->col_count; i++) {
		if (tmp == NULL) {
                    if (strcmp(request->col_info[i].col_name, col_name) == 0) {
		        col_offset = i;
		        break;
                    }
		} else { 
                    if ((strcmp(request->col_info[i].col_name, tmp + 1) == 0) && 
                            (strncmp(request->col_info[i].class_name, col_name, tmp - col_name) == 0)) {
                        col_offset = i;
                        break;
                    }
                }
	    }

	    if (i == request->col_count) {
		handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
		RETURN_FALSE;
	    }
        }
	    break;
	case IS_LONG:
	    convert_to_long_ex(&column);
	    col_offset = Z_LVAL_P(column); 

	    if (col_offset < 0 || col_offset >= request->col_count) {
		handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
		RETURN_FALSE;
	    }

	    break;
	default:
	    handle_error(CCI_ER_COLUMN_INDEX, NULL, request->conn);
	    RETURN_FALSE;
	}
    }

    if ((cubrid_retval = cci_fetch(request->handle, &error)) < 0) {
	handle_error(cubrid_retval, &error, request->conn);
	RETURN_FALSE;
    }

    if ((cubrid_retval = cci_get_data(request->handle, col_offset + 1, 
		    CCI_A_TYPE_STR, &res_buf, &ind)) < 0) {
	handle_error(cubrid_retval, NULL, request->conn);
	RETURN_FALSE;
    }

    if (ind == -1) {
	return; 
    } else {
	RETURN_STRINGL(res_buf, ind, 1);
    }
}

ZEND_FUNCTION(cubrid_unbuffered_query)
{
    zval *conn_id = NULL;
    char *query = NULL;
    int query_len;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;

    T_CCI_COL_INFO *res_col_info = NULL;
    T_CCI_CUBRID_STMT res_sql_type = 0;
    int res_col_count = 0;

    int cubrid_retval = 0;
    int req_handle = 0;
    int req_id = 0;

    init_error ();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &query, &query_len, &conn_id) == FAILURE) {
	return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE; 
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    request = new_cubrid_request();
    if (!request) {
        handle_error(CCI_ER_REQ_HANDLE, NULL, connect);
        RETURN_FALSE;
    }
    request->conn = connect;

    if ((cubrid_retval = cci_prepare(connect->handle, query, 0, &error)) < 0) {
        goto ERR_CUBRID_UNBUFFERED_QUERY;
    }

    req_handle = cubrid_retval;
    request->handle = req_handle;

    if ((cubrid_retval = cci_execute(req_handle, CCI_EXEC_ASYNC, 0, &error)) < 0) {
        goto ERR_CUBRID_UNBUFFERED_QUERY;
    }

    res_col_info = cci_get_result_info(req_handle, &res_sql_type, &res_col_count);
    request->sql_type = res_sql_type;

    if (res_sql_type == CUBRID_STMT_SELECT && !res_col_info) {
        cubrid_retval = CUBRID_ER_CANNOT_GET_COLUMN_INFO;
        goto ERR_CUBRID_UNBUFFERED_QUERY;

    } else if (res_sql_type == CUBRID_STMT_SELECT) {
        request->col_info = res_col_info;
        request->col_count = res_col_count;
    }

    connect->sql_type = request->sql_type;
    request->fetch_field_auto_index = 0;

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
        request->row_count = cubrid_retval;
        if (cubrid_retval > 0 && request->field_lengths == NULL) {
            request->field_lengths = (int *) emalloc (sizeof(int) * res_col_count);
        }

        cubrid_retval = cci_cursor(req_handle, 1, CCI_CURSOR_CURRENT, &error);
        if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
            goto ERR_CUBRID_UNBUFFERED_QUERY;
        }

        CUBRID_G(last_request_id) = req_id;
        connect->affected_rows = 0;

        break;
    case CUBRID_STMT_INSERT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        connect->affected_rows = cubrid_retval;
        break;
    case CUBRID_STMT_CALL:
        request->row_count = cubrid_retval;
        connect->affected_rows = cubrid_retval;
    default:
        break;
    }

    req_id = ZEND_REGISTER_RESOURCE(return_value, request, le_request);
    register_cubrid_request(connect, request);
    php_cubrid_set_default_req(Z_LVAL_P(return_value) TSRMLS_CC);

    if (request->sql_type == CUBRID_STMT_SELECT) {
        return;
    }

    RETURN_TRUE;

ERR_CUBRID_UNBUFFERED_QUERY:
    close_cubrid_request_internal(request);
    handle_error(cubrid_retval, &error, connect);
    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_query)
{
    zval *conn_id = NULL;
    char *query = NULL;
    int query_len;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;

    T_CCI_COL_INFO *res_col_info = NULL;
    T_CCI_CUBRID_STMT res_sql_type = 0;
    int res_col_count = 0;

    int cubrid_retval = 0;
    int exec_retval = 0;
    int req_handle = 0;
    int req_id = 0;

    init_error ();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &query, &query_len, &conn_id) == FAILURE) {
	return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE; 
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    request = new_cubrid_request();
    if (!request) {
        handle_error(CCI_ER_REQ_HANDLE, NULL, connect);
        RETURN_FALSE;
    }
    request->conn = connect;

	if ((cubrid_retval =
		cci_prepare_and_execute(connect->handle, query, 0, &exec_retval, &error)) < 0) {
			if(cubrid_retval == CAS_ER_NOT_IMPLEMENTED) {
				if ((cubrid_retval = cci_prepare(connect->handle, query, 0, &error)) < 0) {
					goto ERR_CUBRID_QUERY;
				}
				if ((exec_retval = cci_execute(cubrid_retval, 0, 0, &error)) < 0) {
					cubrid_retval = exec_retval;
					goto ERR_CUBRID_QUERY;
				}
			} else {
				goto ERR_CUBRID_QUERY;
			}
	}

    req_handle = cubrid_retval;
    request->handle = req_handle;

    res_col_info = cci_get_result_info(req_handle, &res_sql_type, &res_col_count);
    request->sql_type = res_sql_type;

    if (res_sql_type == CUBRID_STMT_SELECT && !res_col_info) {
        cubrid_retval = CUBRID_ER_CANNOT_GET_COLUMN_INFO;
        goto ERR_CUBRID_QUERY;

    } else if (res_sql_type == CUBRID_STMT_SELECT) {
        request->col_info = res_col_info;
        request->col_count = res_col_count;
    }

    connect->sql_type = request->sql_type;
    request->fetch_field_auto_index = 0;

    switch (request->sql_type) {
    case CUBRID_STMT_SELECT:
        request->row_count = exec_retval;
        if (cubrid_retval > 0 && request->field_lengths == NULL) {
            request->field_lengths = (int *) emalloc (sizeof(int) * res_col_count);
        }

        cubrid_retval = cci_cursor(req_handle, 1, CCI_CURSOR_CURRENT, &error);
        if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
            goto ERR_CUBRID_QUERY;
        }

        CUBRID_G(last_request_id) = req_id;
        connect->affected_rows = -1;

        break;
    case CUBRID_STMT_INSERT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        CUBRID_G(last_request_id) = req_id;
        connect->affected_rows = exec_retval;
        break;
    case CUBRID_STMT_CALL:
        request->row_count = exec_retval;
        connect->affected_rows = exec_retval;
    default:
        break;
    }

    req_id = ZEND_REGISTER_RESOURCE(return_value, request, le_request);
    php_cubrid_set_default_req(Z_LVAL_P(return_value) TSRMLS_CC);
    register_cubrid_request(connect, request);

    if (request->sql_type == CUBRID_STMT_SELECT) {
        return;
    }

    RETURN_TRUE;

ERR_CUBRID_QUERY:
    close_cubrid_request_internal(request);
    handle_error(cubrid_retval, &error, connect);
    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_get_charset)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);
    
    if ((cubrid_retval = cubrid_get_charset_internal (connect->handle, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    RETURN_STRING((char *) db_charsets[cubrid_retval].charset_name, 1);
}

ZEND_FUNCTION(cubrid_client_encoding)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
	return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE; 
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    if ((cubrid_retval = cubrid_get_charset_internal (connect->handle, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    RETURN_STRING((char *) db_charsets[cubrid_retval].charset_name, 1);
}

ZEND_FUNCTION(cubrid_get_client_info)
{
    int major, minor, patch;
    char info[128];

    init_error();

    if (zend_parse_parameters_none() == FAILURE) {
	return;
    }

    cci_get_version(&major, &minor, &patch);

    snprintf(info, sizeof(info), "%d.%d.%d", major, minor, patch);

    RETURN_STRING(info, 1);
}

ZEND_FUNCTION(cubrid_get_server_info)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect;

    char buf[64];

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }
    
    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    cci_get_db_version(connect->handle, buf, sizeof(buf));

    RETURN_STRING(buf, 1);
}

ZEND_FUNCTION(cubrid_real_escape_string)
{
    zval *conn_id = NULL;

    char *unescaped_str = NULL;
    int unescaped_str_len = 0;

    char *escaped_str;
    int escaped_str_len = 0;

    int cubrid_retval = 0;
    T_CUBRID_CONNECT *connect = NULL;
    T_CCI_ERROR error;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", 
		&unescaped_str, &unescaped_str_len, &conn_id) == FAILURE) {
	return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
        if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE;
        }

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    escaped_str = (char *) emalloc(2 * unescaped_str_len + 16);
    if (!escaped_str) {
        handle_error(CCI_ER_NO_MORE_MEMORY, NULL, connect);
        RETURN_FALSE;
    }

    memset(escaped_str, 0, 2 * unescaped_str_len + 16);

    if ((cubrid_retval = cci_escape_string (connect->handle,
                    escaped_str, unescaped_str, unescaped_str_len, &error)) < 0) {
        free (escaped_str);
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    RETURN_STRINGL(escaped_str, cubrid_retval, 0);
}

ZEND_FUNCTION(cubrid_get_db_parameter)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    int cubrid_retval = 0;
    int i, val;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &conn_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    array_init(return_value);

    for (i = CCI_PARAM_FIRST; i <= CCI_PARAM_LAST; i++) {
	if ((cubrid_retval = cci_get_db_parameter(connect->handle, (T_CCI_DB_PARAM) i, (void *) &val, &error)) < 0) {
	    handle_error(cubrid_retval, &error, connect);
            cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);
	    RETURN_FALSE;
	}

	add_assoc_long(return_value, (char *) db_parameters[i - 1].parameter_name, val);
    }

    return;
}

ZEND_FUNCTION(cubrid_set_db_parameter)
{
    zval *conn_id = NULL;
    long param_type, param_value;

    T_CUBRID_CONNECT *connect;
    T_CCI_ERROR error;

    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &conn_id, &param_type, &param_value) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    switch (param_type) {
    case CUBRID_PARAM_ISOLATION_LEVEL:
        if ((cubrid_retval = cci_set_isolation_level(connect->handle, param_value, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            RETURN_FALSE; 
        }

        break;
    case CUBRID_PARAM_LOCK_TIMEOUT:
        if ((cubrid_retval = cci_set_db_parameter(connect->handle, param_type, (void *) &param_value, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            RETURN_FALSE;
        }

        break;
    default:
        handle_error(CUBRID_ER_INVALID_PARAM_TYPE, NULL, connect);
        RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_db_name)
{
    zval *db_list = NULL;
    long db_index = 0;

    int db_list_size = 0;
    zval **elem_buf = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al", &db_list, &db_index) == FAILURE) {
	return;
    }

    db_list_size = zend_hash_num_elements(HASH_OF(db_list));
    if (db_index < 0 || db_index >= db_list_size) {
        RETURN_FALSE; 
    }

    zend_hash_internal_pointer_reset(HASH_OF(db_list));
    if (zend_hash_index_find(HASH_OF(db_list), db_index, (void **) &elem_buf) == FAILURE) {
        RETURN_FALSE; 
    }
    convert_to_string_ex(elem_buf);

    RETURN_STRINGL(Z_STRVAL_P(*elem_buf), Z_STRLEN_P(*elem_buf), 1);
}

ZEND_FUNCTION(cubrid_list_dbs) 
{
    zval *conn_id = NULL;
    char *query = "SELECT LIST_DBS()";

    T_CUBRID_CONNECT *connect = NULL;
    T_CCI_ERROR error;

    int cubrid_retval = 0;
    int request_handle = 0;

    char *buffer = NULL;
    int ind = 0;

    int i;
    char *pos = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
	return;
    }

    if (conn_id) {
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
        if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE;
        }

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    array_init(return_value);
   
    if ((cubrid_retval = cci_prepare(connect->handle, query, 0, &error)) < 0) {
	handle_error(cubrid_retval, &error, connect);
	RETURN_FALSE;
    }

    request_handle = cubrid_retval;

    if ((cubrid_retval = cci_execute(request_handle, CCI_EXEC_ASYNC, 0, &error)) < 0) {
        goto ERR_CUBRID_LIST_DBS_HANDLE;
    }

    cubrid_retval = cci_cursor(request_handle, 1, CCI_CURSOR_CURRENT, &error);
    if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
        goto ERR_CUBRID_LIST_DBS_HANDLE;
    }

    if ((cubrid_retval = cci_fetch(request_handle, &error)) < 0) {
        goto ERR_CUBRID_LIST_DBS_HANDLE;
    }

    if ((cubrid_retval = cci_get_data(request_handle, 1, CCI_A_TYPE_STR, &buffer, &ind)) < 0) {
        goto ERR_CUBRID_LIST_DBS_HANDLE;
    }


    /* Databases names are separated by spaces */
    i = 0;
    if (ind != -1) {
	pos = strtok(buffer, " ");
	if (pos) {
	    while (pos != NULL) {
		add_index_stringl(return_value, i++, pos, strlen(pos), 1);
		pos = strtok(NULL, " ");
	    }
	} else {
	    add_index_stringl(return_value, 0, buffer, strlen(buffer), 1);
	}
    } else {
        goto ERR_CUBRID_LIST_DBS;
    }

    cci_close_req_handle(request_handle);
    return;
ERR_CUBRID_LIST_DBS_HANDLE:
	handle_error(cubrid_retval, &error, connect);
ERR_CUBRID_LIST_DBS:

    cci_close_req_handle(request_handle);
    cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);

    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_insert_id)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect = NULL;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    char *last_id = NULL;
    char *out_str = NULL;

    init_error();

    if (CUBRID_G(last_request_id) == -1) {
	RETURN_FALSE;
    }

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
        return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
        if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE; 
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    switch (connect->sql_type) {
    case CUBRID_STMT_INSERT:
        if (connect->affected_rows < 1) {
            RETURN_LONG(0);
        }

        if ((cubrid_retval = cci_get_last_insert_id(connect->handle, &last_id, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            RETURN_FALSE;
        } 
        
        if (last_id == NULL) {
            RETURN_LONG(0);
        } else {
            out_str = estrndup(last_id, strlen(last_id));
            RETURN_STRINGL(out_str, strlen(out_str), 0);
        } 

        break;
    case CUBRID_STMT_SELECT:
    case CUBRID_STMT_UPDATE:
    case CUBRID_STMT_DELETE:
        RETURN_LONG(0);
    default:
        handle_error(CUBRID_ER_INVALID_SQL_TYPE, NULL, connect);
        RETURN_FALSE;
    }
}

ZEND_FUNCTION(cubrid_ping)
{
    zval *conn_id = NULL;

    T_CUBRID_CONNECT *connect = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &conn_id) == FAILURE) {
        return;
    }

    if (conn_id){
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
	if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE; 
        } 

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    if (!check_connect_alive(connect)) {
        RETURN_FALSE;
    } 

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_new)
{
    zval *conn_id = NULL;
    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_LOB2 *cubrid_lob = NULL;

    char *type = NULL;
    int type_len = 0, cubrid_retval = 0;

    T_CCI_U_TYPE u_type = -1;
    T_CCI_LOB lob = NULL;
    T_CCI_ERROR error;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|rs", &conn_id, &type, &type_len) == FAILURE) {
        return;
    }

    if (conn_id) {
        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    } else {
        if (CUBRID_G(last_connect_id) == -1) {
            RETURN_FALSE;
        }

        ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, NULL, CUBRID_G(last_connect_id), "CUBRID-Connect", le_connect, le_pconnect);
    }

    init_error_link(connect);

    if (!type) {
        type = "BLOB";
    }

    u_type = get_cubrid_u_type_by_name(type);
    if (!(u_type == CCI_U_TYPE_BLOB || u_type == CCI_U_TYPE_CLOB)) {
        handle_error(CUBRID_ER_NOT_SUPPORTED_TYPE, NULL, connect);
        RETURN_FALSE;
    }

    if ((cubrid_retval = cubrid_lob_new(connect->handle, &lob, u_type, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    cubrid_lob = new_cubrid_lob2();
    if (!cubrid_lob) {
        handle_error(CCI_ER_NO_MORE_MEMORY, NULL, connect);
        RETURN_FALSE;
    }

    cubrid_lob->lob = lob;
    cubrid_lob->type = u_type;
    cubrid_lob->connect = connect;

    ZEND_REGISTER_RESOURCE(return_value, cubrid_lob, le_lob2);
}

ZEND_FUNCTION(cubrid_lob2_bind)
{
    zval *req_id = NULL, *bind_value = NULL;
    char *bind_value_type = NULL;
    long bind_index = 0, bind_value_type_len;

    T_CUBRID_REQUEST *request = NULL;
    T_CCI_ERROR error;
    T_CUBRID_LOB2 *lob2 = NULL;
    T_CCI_LOB lob = NULL;

    T_CCI_U_TYPE u_type = -1;
    T_CCI_A_TYPE a_type = -1;

    char *value = NULL;
    long value_len = 0;
    
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz|s",
                &req_id, &bind_index, &bind_value, &bind_value_type, &bind_value_type_len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    if (!request->conn) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "CUBRID-Request is not a valid resource");
        return;
    }

    init_error_link(request->conn);

    if (bind_index < 0 || bind_index > request->bind_num) {
        RETURN_FALSE;
    }

    if (!bind_value_type) {
        u_type = CCI_U_TYPE_BLOB;
    } else {
        u_type = get_cubrid_u_type_by_name(bind_value_type);
    }

    if (Z_TYPE_P(bind_value) == IS_RESOURCE) {
        ZEND_FETCH_RESOURCE(lob2, T_CUBRID_LOB2 *, &bind_value, -1, "CUBRID-Lob2", le_lob2);

        if (bind_value_type != NULL && lob2->type != u_type) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Wrong type, the type you create is not %s.", bind_value_type);
            RETURN_FALSE;
        }

        lob = lob2->lob;
        u_type = lob2->type;
    } else {
        value = Z_STRVAL_P(bind_value);
        value_len = Z_STRLEN_P(bind_value);

        if (!(u_type == CCI_U_TYPE_BLOB || u_type == CCI_U_TYPE_CLOB)) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "This function only can be used to bind BLOB/CLOB.");
            RETURN_FALSE;
        }

        if ((cubrid_retval = cubrid_lob_new(request->conn->handle, &lob, u_type, &error)) < 0) {
            handle_error(cubrid_retval, &error, request->conn);
            RETURN_FALSE;
        }

        if ((cubrid_retval = cubrid_lob_write(request->conn->handle, lob, u_type, 0, value_len, value, &error)) < 0) {
            cubrid_lob_free(lob, u_type);
            handle_error(cubrid_retval, &error, request->conn);
            RETURN_FALSE;
        }
    }
    
    switch (u_type) {
    case CCI_U_TYPE_BLOB:
        a_type = CCI_A_TYPE_BLOB;
        break;
    case CCI_U_TYPE_CLOB:
        a_type = CCI_A_TYPE_CLOB;
        break;
    default:
        RETURN_FALSE;
    }
    
    cubrid_retval = cci_bind_param(request->handle, bind_index, a_type, (void *) lob, u_type, CCI_BIND_PTR);
    if (cubrid_retval != 0 || !request->l_bind) {
        handle_error(cubrid_retval, NULL, request->conn);
        RETURN_FALSE;
    }

    request->l_bind[bind_index - 1] = 1;

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_export)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;
    T_CCI_ERROR error;

    char *file_name = NULL, *buf = NULL;
    int file_name_len = 0, cubrid_retval = 0;
    int fd, size;
	int flags = 0;
    php_cubrid_int64_t lob_size, pos = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &lob2_id, &file_name, &file_name_len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

#ifdef PHP_WIN32
	flags = O_BINARY;
#else
	flags = 0;
#endif

    if ((fd = open(file_name, flags | O_CREAT | O_WRONLY | O_EXCL, 0666)) < 0) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "The file that you want to export lob object may have existed.");
        RETURN_FALSE;
    }

    lob_size = cubrid_lob_size(lob->lob, lob->type);
    if (lob_size == 0) {
        close(fd);
        RETURN_TRUE;
    }

    buf = (char *) emalloc (sizeof(char) * CUBRID_LOB_READ_BUF_SIZE);
    if (!buf) {
        handle_error(CCI_ER_NO_MORE_MEMORY, NULL, lob->connect);
        goto ERR_CUBRID_LOB2_EXPORT;
    }

    while (1) {
        size = cubrid_lob_read(lob->connect->handle, lob->lob, lob->type, pos, CUBRID_LOB_READ_BUF_SIZE, buf, &error);

        cubrid_retval = size;

        if (cubrid_retval < 0) {
            handle_error(cubrid_retval, &error, lob->connect);
            goto ERR_CUBRID_LOB2_EXPORT;
        }

        if ((cubrid_retval = write(fd, buf, size)) < 0) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot write the file that you want to export lob object");
            goto ERR_CUBRID_LOB2_EXPORT;
        }

        pos += size;
        if (pos == lob_size) break;

        if (pos > lob_size) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Abnormal error happend in cubrid_lob2_export.\n");
            goto ERR_CUBRID_LOB2_EXPORT;
        }
    }

    efree(buf);
    close(fd);
    RETURN_TRUE;

ERR_CUBRID_LOB2_EXPORT:
    if (fd > 0) {
        close(fd);
        unlink(file_name);
    }
    if (buf) efree(buf);
    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_lob2_import)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;
    T_CCI_ERROR error;

    char *file_name = NULL;
    char buf[CUBRID_LOB_READ_BUF_SIZE] = {'\0'};
    int file_name_len = 0, cubrid_retval = 0;
    int fd, size;
    php_cubrid_int64_t pos = 0;
    int flags;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &lob2_id, &file_name, &file_name_len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

#ifdef PHP_WIN32
    flags = O_RDONLY | O_BINARY;
#else
    flags = O_RDONLY;
#endif

    if ((fd = open(file_name, flags, 0400)) < 0) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot open the file that you want to import lob object.");
        RETURN_FALSE;
    }

    while (1) {
        if ((size = read(fd, buf, CUBRID_LOB_READ_BUF_SIZE)) < 0) {
            close(fd);
            cubrid_lob_free(lob->lob, lob->type);
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot read the file that you want to import lob object.");
            RETURN_FALSE;
        }

        if (size == 0) break;

        if ((cubrid_retval = cubrid_lob_write(lob->connect->handle, lob->lob, lob->type, pos, size, buf, &error)) < 0) {
            close(fd);
            cubrid_lob_free(lob->lob, lob->type);
            handle_error(cubrid_retval, &error, lob->connect);
            RETURN_FALSE;
        }

        pos += size;
    }

    close(fd);
    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_read)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;
    T_CCI_ERROR error;
    long len = 0;
    int cubrid_retval = 0;
    char *buf = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &lob2_id, &len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    if (lob->pos == cubrid_lob_size(lob->lob, lob->type)) {
        RETURN_FALSE;
    }

    buf = (char *) emalloc (sizeof(char) * len + 1);
    if (!buf) {
        handle_error(CCI_ER_NO_MORE_MEMORY, NULL, lob->connect);
        return;
    }

    if ((cubrid_retval = cubrid_lob_read(lob->connect->handle, lob->lob, lob->type, lob->pos, len, buf, &error)) < 0) {
        efree(buf);
        handle_error(cubrid_retval, &error, lob->connect);
        return;
    }

    if (cubrid_retval == len) {
        buf[len] = '\0';
        lob->pos += len;
        RETURN_STRINGL(buf, len, 0);
    } else {
        buf[cubrid_retval] = '\0';
        lob->pos += cubrid_retval;
        RETURN_STRINGL(buf, cubrid_retval, 0);
    }
}

ZEND_FUNCTION(cubrid_lob2_write)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;
    T_CCI_ERROR error;
    int cubrid_retval = 0;
    char *buf = NULL;
    long buf_len = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &lob2_id, &buf, &buf_len) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    if ((cubrid_retval = cubrid_lob_write(lob->connect->handle, lob->lob, lob->type, lob->pos, buf_len, buf, &error)) < 0) {
        handle_error(cubrid_retval, &error, lob->connect);
        RETURN_FALSE;
    }

    lob->pos += buf_len;
    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_tell)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob2_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    RETURN_LONG((long)lob->pos);
}

ZEND_FUNCTION(cubrid_lob2_tell64)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;
    char *pos = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob2_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    pos = php_cubrid_int64_to_str(lob->pos TSRMLS_CC);

    RETURN_STRINGL(pos, strlen(pos), 0);
}

ZEND_FUNCTION(cubrid_lob2_seek)
{
    zval *lob2_id = NULL;

    long offset = 0, origin = CUBRID_CURSOR_CURRENT;
    php_cubrid_int64_t size;

    T_CUBRID_LOB2 *lob = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &lob2_id, &offset, &origin) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    size = cubrid_lob_size(lob->lob, lob->type);

    if (origin == CUBRID_CURSOR_CURRENT) {
        if ((offset < 0 && -offset > lob->pos) || (offset > 0 && (size - lob->pos) < offset)) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "offet(%d) is out of range, please input a proper number.", (int)offset);
            RETURN_FALSE;
        }

        lob->pos += offset;
        RETURN_TRUE;
    }

    if (offset < 0 || offset > size) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset(%d) is not correct, it can't be a negative number or larger than size", (int)offset);
        RETURN_FALSE;
    }
    
    if (origin == CUBRID_CURSOR_FIRST) {
        lob->pos = offset;
    } else if (origin == CUBRID_CURSOR_LAST) {
        lob->pos = size - offset;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_seek64)
{
    zval *lob2_id = NULL;

    char *offset = NULL, *end_offset = NULL;
    int offset_len = 0;
    long origin = CUBRID_CURSOR_CURRENT;
    php_cubrid_int64_t size, index;

    T_CUBRID_LOB2 *lob = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &lob2_id, &offset, &offset_len, &origin) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    size = cubrid_lob_size(lob->lob, lob->type);

    if (offset_len >= 65) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "string(%s) is out of range for the lob field you have chosen, so please check the offset you give and the lob length.", offset);
        RETURN_FALSE;
    }

    index = strtoll(offset, &end_offset, 10);
    if (end_offset == offset) {
        handle_error(CUBRID_ER_INVALID_PARAM, NULL, lob->connect);
        RETURN_FALSE;
    }

    if (origin == CUBRID_CURSOR_CURRENT) {
        if ((index < 0 && -index > lob->pos) || (index > 0 && (size - lob->pos) < index)) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset(%s) is out of range for the lob field you have chosen, so please check the offset you give and the lob length.", offset);
            RETURN_FALSE;
        }

        lob->pos += index;
    }else{
        if (index < 0) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset(%s) must not be a negative number, so please check the offset you give.", offset);
            RETURN_FALSE;
        }

        if (index > size) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "offset(%s) is out of range for the lob field you have chosen, so please check the offset you give and the lob length.", offset);
            RETURN_FALSE;
        }        
    }

    if (origin == CUBRID_CURSOR_FIRST) {
        lob->pos = index;
    } else if (origin == CUBRID_CURSOR_LAST) {
        lob->pos = size - index;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob2_size)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;

    int cubrid_retval = 0;
    php_cubrid_int64_t size;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob2_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    size = cubrid_lob_size(lob->lob, lob->type);

    RETURN_LONG((long)size);
}

ZEND_FUNCTION(cubrid_lob2_size64)
{
    zval *lob2_id = NULL;

    T_CUBRID_LOB2 *lob = NULL;

    int cubrid_retval = 0;
    php_cubrid_int64_t lob_size;
    char *size = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob2_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    init_error_link(lob->connect);

    lob_size = cubrid_lob_size(lob->lob, lob->type);

    size = php_cubrid_int64_to_str(lob_size TSRMLS_CC);

    RETURN_STRINGL(size, strlen(size), 0);
}

ZEND_FUNCTION(cubrid_lob2_close)
{
    zval *lob2_id = NULL;
    T_CUBRID_LOB2 *lob = NULL;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob2_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB2 *, &lob2_id, -1, "CUBRID-Lob2", le_lob2);

    if (!(lob->connect && lob->lob)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid CUBRID-Lob2 resource");
        RETURN_FALSE;
    }

    zend_list_delete(Z_RESVAL_P(lob2_id));

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob_get)
{
    zval *conn_id = NULL;
    char *sql_stmt = NULL;
    int sql_stmt_len;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_LOB *cubrid_lob = NULL;

    T_CCI_LOB lob = NULL;
    T_CCI_ERROR error;

    int req_handle = 0;
    int cubrid_retval = 0;
    int ind = 0;

    T_CCI_A_TYPE a_type = -1;
    T_CCI_U_TYPE u_type = -1;

    T_CCI_COL_INFO *res_col_info;
    T_CCI_SQLX_CMD cmd_type;

    int column_count = 0;
    int row_count = 0;
    int res_id = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &conn_id, &sql_stmt, &sql_stmt_len) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);

    init_error_link(connect);

    if (!sql_stmt) {
        RETURN_FALSE;
    }

    if ((cubrid_retval = cci_prepare(connect->handle, sql_stmt, 0, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    req_handle = cubrid_retval;

    array_init(return_value);

    res_col_info = cci_get_result_info(req_handle, &cmd_type, &column_count);
    if (!res_col_info || cmd_type != CUBRID_STMT_SELECT) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Get result info fail or sql type is not select");
        goto ERR_CUBRID_LOB_GET;
    }

    if (column_count > 1) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "More than one columns returned");
        goto ERR_CUBRID_LOB_GET;
    }

    u_type = CCI_GET_RESULT_INFO_TYPE(res_col_info, 1);

    if (u_type == CCI_U_TYPE_BLOB) {
        a_type = CCI_A_TYPE_BLOB; 
    } else if (u_type == CCI_U_TYPE_CLOB) {
        a_type = CCI_A_TYPE_CLOB; 
    } else {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Column type is not BLOB or CLOB.");
        goto ERR_CUBRID_LOB_GET;
    }

    if ((cubrid_retval = cci_execute(req_handle, 0, 0, &error)) < 0) {
        handle_error(cubrid_retval, &error, connect);
        RETURN_FALSE;
    }

    while (1) {
        cubrid_retval = cci_cursor(req_handle, 1, CCI_CURSOR_CURRENT, &error);
        if (cubrid_retval == CCI_ER_NO_MORE_DATA) {
            break;
        }

        if (cubrid_retval < 0) {
            handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_LOB_GET;
        }

        if ((cubrid_retval = cci_fetch(req_handle, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            goto ERR_CUBRID_LOB_GET;
        }

        if ((cubrid_retval = cci_get_data(req_handle, 1, a_type, (void *) &lob, &ind)) < 0) {
            handle_error(cubrid_retval, NULL, connect);
            goto ERR_CUBRID_LOB_GET;
        }

        if (ind < 0) {
            goto ERR_CUBRID_LOB_GET;
        }

        cubrid_lob = new_cubrid_lob();
        if (!cubrid_lob) {
            handle_error(CCI_ER_NO_MORE_MEMORY, NULL, connect);
            RETURN_FALSE;
        }
        cubrid_lob->lob = lob;
        cubrid_lob->type = u_type;
        cubrid_lob->size = cubrid_lob_size(lob, u_type);

        res_id = ZEND_REGISTER_RESOURCE(NULL, cubrid_lob, le_lob);
        add_index_resource(return_value, row_count, res_id);

        row_count++;
    }

    cci_close_req_handle(req_handle);
    return;

ERR_CUBRID_LOB_GET:

    cubrid_array_destroy(return_value->value.ht ZEND_FILE_LINE_CC);
    cci_close_req_handle(req_handle);

    RETURN_FALSE;
}

ZEND_FUNCTION(cubrid_lob_size)
{
    zval *lob_id = NULL;
    T_CUBRID_LOB *lob = NULL;

    char *id = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &lob_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB *, &lob_id, -1, "CUBRID-Lob", le_lob);

    id = php_cubrid_int64_to_str(lob->size TSRMLS_CC);

    RETURN_STRINGL(id, strlen(id), 0);
}

ZEND_FUNCTION(cubrid_lob_export)
{
    zval *conn_id = NULL, *lob_id = NULL;
    char *file_name = NULL;
    int file_name_len = 0;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_LOB *lob = NULL;
    T_CCI_ERROR error;

    php_stream *stm = NULL;
    
    char buf[CUBRID_LOB_READ_BUF_SIZE];
    php_cubrid_int64_t lob_size = 0, start_pos = 0;
    int write_len = 0;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrs", &conn_id, &lob_id, &file_name, &file_name_len) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB *, &lob_id, -1, "CUBRID-Lob", le_lob);

    init_error_link(connect);

    if (!(stm = php_stream_open_wrapper(file_name, "w", REPORT_ERRORS, NULL))) {
        RETURN_FALSE;
    }

    lob_size = lob->size;

    while (lob_size > 0) {
        if (lob_size < CUBRID_LOB_READ_BUF_SIZE) {
            write_len = (int)lob_size; 
        } else {
            write_len = CUBRID_LOB_READ_BUF_SIZE; 
        }

        if ((cubrid_retval = cubrid_lob_read(connect->handle, lob->lob, lob->type, start_pos, write_len, buf, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            php_stream_close(stm);

            RETURN_FALSE;
        }
        php_stream_write(stm, buf, write_len);

        start_pos += CUBRID_LOB_READ_BUF_SIZE;
        lob_size -= CUBRID_LOB_READ_BUF_SIZE;
    }

    php_stream_close(stm);

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob_send) 
{
    zval *conn_id = NULL, *lob_id = NULL;

    T_CUBRID_CONNECT *connect = NULL;
    T_CUBRID_LOB *lob = NULL;
    T_CCI_ERROR error;

    char buf[CUBRID_LOB_READ_BUF_SIZE];
    php_cubrid_int64_t lob_size = 0, start_pos = 0;
    int write_len = 0;
    int cubrid_retval = 0;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr", &conn_id, &lob_id) == FAILURE) {
	return;
    }

    ZEND_FETCH_RESOURCE2(connect, T_CUBRID_CONNECT *, &conn_id, -1, "CUBRID-Connect", le_connect, le_pconnect);
    ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB *, &lob_id, -1, "CUBRID-Lob", le_lob);

    init_error_link(connect);

    lob_size = lob->size;

    while (lob_size > 0) {
        if (lob_size < CUBRID_LOB_READ_BUF_SIZE) {
            write_len = (int)lob_size; 
        } else {
            write_len = CUBRID_LOB_READ_BUF_SIZE; 
        }

        if ((cubrid_retval = cubrid_lob_read(connect->handle, lob->lob, lob->type, start_pos, write_len, buf, &error)) < 0) {
            handle_error(cubrid_retval, &error, connect);
            RETURN_FALSE;
        }

        if (PHPWRITE(buf, write_len) != write_len) {
	    handle_error(CUBRID_ER_TRANSFER_FAIL, NULL, connect);
            RETURN_FALSE;
	}

        start_pos += CUBRID_LOB_READ_BUF_SIZE;
        lob_size -= CUBRID_LOB_READ_BUF_SIZE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_lob_close)
{
    zval *lob_id_array = NULL;
    T_CUBRID_LOB *lob = NULL;

    int lob_id_count = 0, i;
    zval **data = NULL;

    init_error();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &lob_id_array) == FAILURE) {
	return;
    }

    lob_id_count = zend_hash_num_elements(HASH_OF(lob_id_array));
    zend_hash_internal_pointer_reset(HASH_OF(lob_id_array));

    for (i = 0; i < lob_id_count; i++) {
        zend_hash_get_current_data(HASH_OF(lob_id_array), (void **) &data);

        ZEND_FETCH_RESOURCE(lob, T_CUBRID_LOB *, data, -1, "CUBRID-Lob", le_lob);
        zend_list_delete(Z_RESVAL_PP(data));

        zend_hash_move_forward(HASH_OF(lob_id_array));
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_set_query_timeout)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;
    long timeout = 0;
    int cubrid_retval = 0;

    init_error ();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &req_id, &timeout) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link (request->conn);

    if ((cubrid_retval = cci_set_query_timeout (request->handle, timeout)) < 0) {
        handle_error (cubrid_retval, NULL, request->conn);
        RETURN_FALSE;
    }

    RETURN_TRUE;
}

ZEND_FUNCTION(cubrid_get_query_timeout)
{
    zval *req_id = NULL;
    T_CUBRID_REQUEST *request;
    int timeout;

    init_error ();

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &req_id) == FAILURE) {
        return;
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link (request->conn);

    if ((timeout = cci_get_query_timeout (request->handle)) < 0) {
        handle_error (timeout, NULL, request->conn);
        RETURN_FALSE;
    }

    RETURN_LONG (timeout);
}

/************************************************************************
* PRIVATE FUNCTIONS IMPLEMENTATION
************************************************************************/

static void php_cubrid_set_default_conn(int id TSRMLS_DC)
{
    if (CUBRID_G(last_connect_id) != -1) {
        zend_list_delete(CUBRID_G(last_connect_id));
    }

    CUBRID_G(last_connect_id) = id;
    zend_list_addref(id);
}

static void php_cubrid_set_default_req(int id TSRMLS_DC)
{
    if (CUBRID_G(last_request_id) != -1) {
        zend_list_delete(CUBRID_G(last_request_id));
    }

    CUBRID_G(last_request_id) = id;
    zend_list_addref(id);
}

static void close_cubrid_connect(zend_rsrc_list_entry * rsrc TSRMLS_DC)
{
    T_CUBRID_CONNECT *conn = (T_CUBRID_CONNECT *)rsrc->ptr;
    T_CCI_ERROR error;
    LINKED_LIST_NODE *p;
    LINKED_LIST_NODE *head = conn->unclosed_requests->head;

    /* When calling cci_disconnect, all request handle in cci will be released,
     * just like calling cci_close_req_handle. So we must prevent the PHP
     * garbage collector calling cci_close_req_handle again in close_cubrid_request.
     */

    for (p = head->next; p != NULL ; p = head->next) {
        int i;
        T_CUBRID_REQUEST *req = (T_CUBRID_REQUEST *)p->data;
        req->conn = NULL;
        req->handle = 0;

        if (req->lob2_list) {
            for (i = 0; i < req->col_count; i++) {
                if (req->lob2_list[i]) {
                    req->lob2_list[i]->connect = NULL;
                    req->lob2_list[i] = NULL;
                }
            }
        }

        p->data = NULL;

        head->next = p->next;
        efree(p);
    }

    if (conn->handle) {
	/* CCI_ER_USED_CONNECTION == -20044 */
	while (cci_disconnect(conn->handle, &error) == -20044) {
	    cci_cancel(conn->handle);
	}
    }

    efree(head);
    efree(conn->unclosed_requests);
    efree(conn);
}

static void close_cubrid_pconnect(zend_rsrc_list_entry * rsrc TSRMLS_DC)
{
    T_CUBRID_CONNECT *conn = (T_CUBRID_CONNECT *)rsrc->ptr;

    T_CCI_ERROR error;

    if (conn->handle) {
	/* CCI_ER_USED_CONNECTION == -20044 */
	while (cci_disconnect(conn->handle, &error) == -20044) {
	    cci_cancel(conn->handle);
	}
    }

    free(conn->unclosed_requests->head);
    free(conn->unclosed_requests);
    free(conn);
}

static int is_connection_exist(T_CUBRID_REQUEST *req)
{
    return req->conn ? 1 : 0;
}

static void close_cubrid_request_internal(T_CUBRID_REQUEST * req)
{
    if (is_connection_exist(req)) {
        linked_list_delete(req->conn->unclosed_requests, (void *)req);
        cci_close_req_handle(req->handle);
    }

    if (req->l_bind) {
        efree(req->l_bind);
    }

    if (req->field_lengths) {
        efree(req->field_lengths);
    }

    if (req->lob2_list) {
        int i;
        for (i = 0; i < req->col_count; i++) {
            if (req->lob2_list[i]) {
                req->lob2_list[i]->connect = NULL;
                req->lob2_list[i] = NULL;
            }
        }

        efree(req->lob2_list);
    }

    efree(req);
}

static void close_cubrid_request(zend_rsrc_list_entry * rsrc TSRMLS_DC)
{
    T_CUBRID_REQUEST *req = (T_CUBRID_REQUEST *)rsrc->ptr;

    close_cubrid_request_internal(req);
}


static void close_cubrid_lob_internal(T_CUBRID_LOB *lob)
{
    if (lob->lob) {
        cubrid_lob_free(lob->lob, lob->type);
    }

    efree(lob);
}

static void close_cubrid_lob(zend_rsrc_list_entry * rsrc TSRMLS_DC)
{
    T_CUBRID_LOB *lob = (T_CUBRID_LOB *)rsrc->ptr;

    close_cubrid_lob_internal (lob);
}

static void close_cubrid_lob2(zend_rsrc_list_entry * rsrc TSRMLS_DC)
{
    T_CUBRID_LOB2 *lob = (T_CUBRID_LOB2 *)rsrc->ptr;

    cubrid_lob_free(lob->lob, lob->type);
    efree(lob);
}

static void php_cubrid_init_globals(zend_cubrid_globals * cubrid_globals)
{
    cubrid_globals->recent_error.code = 0;
    cubrid_globals->recent_error.facility = 0;
    cubrid_globals->recent_error.msg[0] = 0;

    cubrid_globals->last_connect_id = -1;
    cubrid_globals->last_request_id = -1;

    cubrid_globals->default_userid = "PUBLIC";
    cubrid_globals->default_passwd = "";
}

static int init_error(void)
{
    set_error(0, 0, "");

    return SUCCESS;
}

static int set_error(T_FACILITY_CODE facility, int code, char *msg, ...)
{
    va_list args;
    TSRMLS_FETCH();

    CUBRID_G(recent_error).facility = facility;
    CUBRID_G(recent_error).code = code;

    va_start(args, msg);
    snprintf(CUBRID_G(recent_error).msg, 1024, msg, args);
    va_end(args);

    return SUCCESS;
}

static int init_error_link(T_CUBRID_CONNECT *conn)
{
    if (conn) {
        set_error_link(conn, 0, "");
    }

    return SUCCESS;
}

static int set_error_link(T_CUBRID_CONNECT *conn, int code, char *msg, ...)
{
    va_list args;

    conn->recent_error.code = code;

    va_start(args, msg);
    snprintf(conn->recent_error.msg, 1024, msg, args);
    va_end(args);

    return SUCCESS;
}

static int get_error_msg(int err_code, char *buf, int buf_size)
{
    const char *err_msg = "";
    int size = sizeof(db_error) / sizeof(db_error[0]);
    int i;

    if (err_code > CCI_ER_END) {
	return cci_get_err_msg(err_code, buf, buf_size);
    }

    for (i = 0; i < size; i++) {
	if (err_code == db_error[i].err_code) {
	    err_msg = db_error[i].err_msg;
	    break;
	}
    }

    if (i == size) {
	err_msg = "Unknown Error";
    }

    strlcpy(buf, err_msg, buf_size);

    return SUCCESS;
}

static int handle_error(int err_code, T_CCI_ERROR * error, T_CUBRID_CONNECT *conn)
{
    int real_err_code = 0;
    char *real_err_msg = NULL;

    T_FACILITY_CODE facility = CUBRID_FACILITY_CLIENT;

    char err_msg[1024] = { 0 };
    char *facility_msg = NULL;

    if (err_code == CCI_ER_DBMS) {
	facility = CUBRID_FACILITY_DBMS;
	facility_msg = "DBMS";
	if (error) {
	    real_err_code = error->err_code;
	    real_err_msg = error->err_msg;
	} else {
	    real_err_code = 0;
	    real_err_msg = "Unknown DBMS error";
	}
    } else {
	if (err_code > CAS_ER_IS) {
	    facility = CUBRID_FACILITY_CAS;
	    facility_msg = "CAS";
	} else if (err_code > CCI_ER_END) {
	    facility = CUBRID_FACILITY_CCI;
	    facility_msg = "CCI";
	} else if (err_code > CUBRID_ER_END) {
	    facility = CUBRID_FACILITY_CLIENT;
	    facility_msg = "CLIENT";
	} else {
	    real_err_code = -1;
	    real_err_msg = NULL;
	    return FAILURE;
	}

	if (get_error_msg(err_code, err_msg, (int) sizeof(err_msg)) < 0) {
	    strlcpy(err_msg, "Unknown error message", sizeof(err_msg));
	}

	real_err_code = err_code;
	real_err_msg = err_msg;
    }

    set_error(facility, real_err_code, real_err_msg);

    if(conn) {
        set_error_link(conn, real_err_code, real_err_msg);
    }

    php_error(E_WARNING, "Error: %s, %d, %s", facility_msg, real_err_code, real_err_msg);

    return SUCCESS;
}

static int fetch_a_row(zval *arg, T_CUBRID_CONNECT *connect, int req_handle, T_CUBRID_REQUEST *request, int type TSRMLS_DC)
{
    T_CCI_COL_INFO *column_info = NULL;
    T_CCI_U_TYPE column_type;

    LINKED_LIST_NODE *cur= NULL;

    int column_count = 0;
    char *column_name;

    int cubrid_retval = 0;
    int null_indicator;
    int i;

    if ((column_info = cci_get_result_info(req_handle, NULL, &column_count)) == NULL) {
	return CUBRID_ER_CANNOT_GET_COLUMN_INFO;
    }

    array_init(arg);

    for (i = 0; i < column_count; i++) { 
        column_type = CCI_GET_RESULT_INFO_TYPE(column_info, i + 1);
	column_name = CCI_GET_RESULT_INFO_NAME(column_info, i + 1);

        if (CCI_IS_SET_TYPE(column_type) || CCI_IS_MULTISET_TYPE(column_type) || CCI_IS_SEQUENCE_TYPE(column_type)) {
	    T_CCI_SET res_buf = NULL;

	    if ((cubrid_retval = cci_get_data(req_handle, i + 1, CCI_A_TYPE_SET, &res_buf, &null_indicator)) < 0) {
		goto ERR_FETCH_A_ROW;
	    }

	    if (null_indicator >= 0) {
		if (type & CUBRID_NUM) {
		    cubrid_retval = cubrid_add_index_array(arg, i, res_buf TSRMLS_CC);
		} 
		
		if (type & CUBRID_ASSOC) {
		    cubrid_retval = cubrid_add_assoc_array(arg, column_name, res_buf TSRMLS_CC);
		}
		
		if (cubrid_retval < 0) {
		    cci_set_free(res_buf);
		    goto ERR_FETCH_A_ROW;
		}

		cci_set_free(res_buf);
	    }

	} else if ((type & CUBRID_LOB) && (column_type == CCI_U_TYPE_BLOB || column_type == CCI_U_TYPE_CLOB)) {
            T_CCI_LOB lob = NULL;
            T_CUBRID_LOB2 *cubrid_lob = NULL;
            int res_id = 0;

            if (column_type == CCI_U_TYPE_BLOB) {
                if ((cubrid_retval = cci_get_data(req_handle, i + 1, CCI_A_TYPE_BLOB, (void *) &lob, &null_indicator)) < 0) {
                    goto ERR_FETCH_A_ROW;
                }
            } else {
                if ((cubrid_retval = cci_get_data(req_handle, i + 1, CCI_A_TYPE_CLOB, (void *) &lob, &null_indicator)) < 0) {
                    goto ERR_FETCH_A_ROW;
                }
            }

            if (null_indicator >= 0) {
                cubrid_lob = new_cubrid_lob2();
                if (!cubrid_lob) {
                    cubrid_lob_free(lob, column_type);
                    cubrid_retval = CCI_ER_NO_MORE_MEMORY;
                    goto ERR_FETCH_A_ROW;
                }

                cubrid_lob->lob = lob;
                cubrid_lob->type = column_type;
                cubrid_lob->connect = connect;

                res_id = ZEND_REGISTER_RESOURCE(NULL, cubrid_lob, le_lob2);

                if (request) {
                    request->lob2_list[i] = cubrid_lob;
                }

                if (type & CUBRID_NUM) {
                    add_index_resource(arg, i, res_id);
                }

                if (type & CUBRID_ASSOC) {
                    add_assoc_resource(arg, column_name, res_id);
                }
            }

        } else {
	    char *res_buf = NULL;

	    if ((cubrid_retval = cci_get_data(req_handle, i + 1, CCI_A_TYPE_STR, &res_buf, &null_indicator)) < 0) {
		goto ERR_FETCH_A_ROW;
	    }

	    if (null_indicator >= 0) {
		if (type & CUBRID_NUM) {
		    add_index_stringl(arg, i, res_buf, null_indicator, 1);
		} 
		
		if (type & CUBRID_ASSOC) {
		    add_assoc_stringl(arg, column_name, res_buf, null_indicator, 1);
		}
	    }
	}

        if (request && request->field_lengths != NULL) {
            if (null_indicator != -1) {
                request->field_lengths[i] = null_indicator;
            } else {
                request->field_lengths[i] = 0;
            }
        }

        if (null_indicator < 0) {
            if (type & CUBRID_NUM) {
                add_index_unset(arg, i);
            }

            if (type & CUBRID_ASSOC) {
                add_assoc_unset(arg, column_name);
            }
        }
    }

    return SUCCESS;

ERR_FETCH_A_ROW:
    cubrid_array_destroy(arg->value.ht ZEND_FILE_LINE_CC);
    return cubrid_retval;
}

static T_CUBRID_CONNECT *new_cubrid_connect(int persistent)
{
    T_CUBRID_CONNECT *connect = NULL;

    if (persistent) {
        connect = (T_CUBRID_CONNECT *) malloc(sizeof(T_CUBRID_CONNECT));
        if (!connect) {
            return NULL;
        }

        connect->unclosed_requests = 
            (LINKED_LIST *) malloc(sizeof(LINKED_LIST));
        if (!connect->unclosed_requests) {
            goto ERR_CUBRID_CONNECT;
        }

        connect->unclosed_requests->head =
            (LINKED_LIST_NODE *) malloc(sizeof(LINKED_LIST_NODE));
        if (!connect->unclosed_requests->head) {
            goto ERR_CUBRID_CONNECT;
        }
    } else {
        connect = (T_CUBRID_CONNECT *) emalloc(sizeof(T_CUBRID_CONNECT));
        if (!connect) {
            return NULL;
        }

        connect->unclosed_requests = 
            (LINKED_LIST *) emalloc(sizeof(LINKED_LIST));
        if (!connect->unclosed_requests) {
            goto ERR_CUBRID_CONNECT;
        }

        connect->unclosed_requests->head =
            (LINKED_LIST_NODE *) emalloc(sizeof(LINKED_LIST_NODE));
        if (!connect->unclosed_requests->head) {
            goto ERR_CUBRID_CONNECT;
        }
    }

    connect->unclosed_requests->head->data = NULL;
    connect->unclosed_requests->head->next = NULL;
    connect->unclosed_requests->tail = connect->unclosed_requests->head;

    connect->recent_error.code = 0;
    connect->recent_error.msg[0] = 0;
    connect->handle = 0;

    connect->persistent = persistent;

    connect->affected_rows = 0;
    connect->sql_type = 0;

    return connect;

ERR_CUBRID_CONNECT:
    if (connect->unclosed_requests) {
        if (persistent) {
            free(connect->unclosed_requests);
        } else {
            efree(connect->unclosed_requests);
        }
    }

    if (connect) {
        if (persistent) {

            free(connect);
        } else {
            efree(connect);
        }
    }

    return NULL;
}

static T_CUBRID_REQUEST *new_cubrid_request(void)
{
    T_CUBRID_REQUEST *request = (T_CUBRID_REQUEST *) emalloc (sizeof(T_CUBRID_REQUEST));
    
    if (!request) return NULL;

    request->lob2_list = NULL;

    request->conn = NULL;
    request->handle = 0;
    request->row_count = -1;
    request->col_count = -1;
    request->sql_type = 0;
    request->bind_num = -1;
    request->l_bind = NULL;
    request->l_prepare = 0;
    request->field_lengths = NULL;
    request->lob = NULL;

    return request;
}

static T_CUBRID_LOB *new_cubrid_lob(void)
{
    T_CUBRID_LOB *lob = (T_CUBRID_LOB *) emalloc(sizeof(T_CUBRID_LOB));

    if (!lob) return NULL;

    lob->lob = NULL;
    lob->size = 0;
    lob->type = CCI_U_TYPE_BLOB;

    return lob;
}

static T_CUBRID_LOB2 *new_cubrid_lob2(void)
{
    T_CUBRID_LOB2 *lob = (T_CUBRID_LOB2 *) emalloc(sizeof(T_CUBRID_LOB2));
    
    if (!lob) return NULL;

    lob->connect = NULL;
    lob->pos = 0;
    lob->type = CCI_U_TYPE_BLOB;

    return lob;
}

static void register_cubrid_request(T_CUBRID_CONNECT *conn, T_CUBRID_REQUEST *req)
{
    linked_list_append(conn->unclosed_requests, (void *)req);
}

static int cubrid_add_index_array(zval *arg, uint index, T_CCI_SET in_set TSRMLS_DC)
{
    zval *tmp_ptr;

    int i;
    int res;
    int ind;
    char *buffer;

    int set_size = cci_set_size(in_set);

    MAKE_STD_ZVAL(tmp_ptr);
    array_init(tmp_ptr);

    for (i = 0; i < set_size; i++) {
	res = cci_set_get(in_set, i + 1, CCI_A_TYPE_STR, &buffer, &ind);
	if (res < 0) {
	    cubrid_array_destroy(HASH_OF(tmp_ptr) ZEND_FILE_LINE_CC);
	    FREE_ZVAL(tmp_ptr);
	    return res;
	}

	if (ind < 0) {
	    add_index_unset(tmp_ptr, i);
	} else {
	    add_index_string(tmp_ptr, i, buffer, 1);
	}
    }

    res = zend_hash_index_update(HASH_OF(arg), index, (void *) &tmp_ptr, sizeof(zval *), NULL);
    if (res == FAILURE) {
	cubrid_array_destroy(HASH_OF(tmp_ptr) ZEND_FILE_LINE_CC);
	FREE_ZVAL(tmp_ptr);
	return CUBRID_ER_PHP;
    }

    return 0;
}

static int cubrid_add_assoc_array(zval *arg, char *key, T_CCI_SET in_set TSRMLS_DC)
{
    zval *tmp_ptr;

    int i;
    int ind;
    char *buffer;
    int cubrid_retval = 0;

    int set_size = cci_set_size(in_set);

    MAKE_STD_ZVAL(tmp_ptr);
    array_init(tmp_ptr);

    for (i = 0; i < set_size; i++) {
	if ((cubrid_retval = cci_set_get(in_set, i + 1, CCI_A_TYPE_STR, &buffer, &ind)) < 0) {
	    cubrid_array_destroy(HASH_OF(tmp_ptr) ZEND_FILE_LINE_CC);
	    FREE_ZVAL(tmp_ptr);
	    return cubrid_retval;
	}

	if (ind < 0) {
	    add_index_unset(tmp_ptr, i);
	} else {
	    add_index_string(tmp_ptr, i, buffer, 1);
	}
    }

    if ((cubrid_retval = zend_hash_update(HASH_OF(arg), key, strlen(key) + 1, 
		    (void *) &tmp_ptr, sizeof(zval *), NULL)) == FAILURE) {
	cubrid_array_destroy(HASH_OF(tmp_ptr) ZEND_FILE_LINE_CC);
	FREE_ZVAL(tmp_ptr);
	return CUBRID_ER_PHP;
    }

    return 0;
}

static int cubrid_array_destroy(HashTable * ht ZEND_FILE_LINE_DC)
{
    zend_hash_destroy(ht);
    FREE_HASHTABLE_REL(ht);
    return SUCCESS;
}

static int cubrid_make_set(HashTable *ht, T_CCI_SET *set)
{
    void **set_array = NULL;
    int *set_null = NULL;
    char *key;
    ulong index;
    zval **data;

    int set_size;
    int i;
    int error_code;
    int cubrid_retval = 0;

    set_size = zend_hash_num_elements(ht);
    set_array = (void **) safe_emalloc(set_size, sizeof(void *), 0);

    for (i = 0; i < set_size; i++) {
	set_array[i] = NULL;
    }

    set_null = (int *) safe_emalloc(set_size, sizeof(int), 0);

    zend_hash_internal_pointer_reset(ht);
    for (i = 0; i < set_size; i++) {
	if (zend_hash_get_current_key(ht, &key, &index, 0) == HASH_KEY_NON_EXISTANT) {
	    break;
	}

	zend_hash_get_current_data(ht, (void **) &data);
	switch (Z_TYPE_PP(data)) {
	case IS_NULL:
	    set_array[i] = NULL;
	    set_null[i] = 1;

	    break;
	case IS_LONG:
	case IS_DOUBLE:
	    convert_to_string_ex(data);
	case IS_STRING:
	    set_array[i] = Z_STRVAL_PP(data);
	    set_null[i] = 0;

	    break;
	default:
	    error_code = CUBRID_ER_NOT_SUPPORTED_TYPE;
	    goto ERR_CUBRID_MAKE_SET;
	}

	zend_hash_move_forward(ht);
    }

    if ((cubrid_retval = cci_set_make(set, CCI_U_TYPE_STRING, set_size, set_array, set_null)) < 0) {
	*set = NULL;
	error_code = cubrid_retval;
	goto ERR_CUBRID_MAKE_SET;
    }

    efree(set_array);
    efree(set_null);

    return 0;

ERR_CUBRID_MAKE_SET:

    if (set_array) {
	efree(set_array);
    }

    if (set_null) {
	efree(set_null);
    }

    return error_code;
}

static int type2str(T_CCI_COL_INFO * column_info, char *type_name, int type_name_len)
{
    char buf[64] = {'\0'};
    int u_type;
	int i = 0;
	int len = (sizeof(cubrid_type2name) / sizeof(cubrid_type2name[0]));

    u_type = CCI_GET_COLLECTION_DOMAIN(column_info->ext_type);

	for(i = 0;i<len; i++) {
      if (cubrid_type2name[i].type == u_type) {
        snprintf(buf, sizeof(buf), cubrid_type2name[i].name);
      }
    }   
	if(buf[0] == '\0')
		snprintf(buf, sizeof(buf), cubrid_type2name[0].name);
	
    if (CCI_IS_SET_TYPE(column_info->ext_type)) {
        snprintf(type_name, type_name_len, "set(%s)", buf);
    } else if (CCI_IS_MULTISET_TYPE(column_info->ext_type)) {
        snprintf(type_name, type_name_len, "multiset(%s)", buf);
    } else if (CCI_IS_SEQUENCE_TYPE(column_info->ext_type)) {
        snprintf(type_name, type_name_len, "sequence(%s)", buf);
    } else {
        snprintf(type_name, type_name_len, "%s", buf);
    }

    return 0;
}

static int numeric_type(T_CCI_U_TYPE type)
{
    if (type == CCI_U_TYPE_NUMERIC || 
	type == CCI_U_TYPE_INT ||
	type == CCI_U_TYPE_SHORT || 
	type == CCI_U_TYPE_FLOAT ||
	type == CCI_U_TYPE_DOUBLE || 
	type == CCI_U_TYPE_BIGINT ||
	type == CCI_U_TYPE_MONETARY) {
	return 1;
    } else {
	return 0;
    }
}

static int get_cubrid_u_type_by_name(const char *type_name)
{
    int i;
    int size = sizeof(db_type_info) / sizeof(db_type_info[0]);

    for (i = 0; i < size; i++) {
	if (strcasecmp(type_name, db_type_info[i].type_name) == 0) {
	    return db_type_info[i].cubrid_u_type;
	}
    }

    return U_TYPE_UNKNOWN;
}

static int get_cubrid_u_type_len(T_CCI_U_TYPE type)
{
    int i;
    int size = sizeof(db_type_info) / sizeof(db_type_info[0]);
    DB_TYPE_INFO type_info;

    for (i = 0; i < size; i++) {
	type_info = db_type_info[i];
	if (type == type_info.cubrid_u_type) {
	    return type_info.len;
	}
    }

    return 0;
}

static int cubrid_lob_new(int con_h_id, T_CCI_LOB *lob, T_CCI_U_TYPE type, T_CCI_ERROR *err_buf)
{
    return (type == CCI_U_TYPE_BLOB) ? 
        cci_blob_new(con_h_id, lob, err_buf) : cci_clob_new(con_h_id, lob, err_buf);
}

static php_cubrid_int64_t cubrid_lob_size(T_CCI_LOB lob, T_CCI_U_TYPE type)
{
    return (type == CCI_U_TYPE_BLOB) ? cci_blob_size(lob) : cci_clob_size(lob);
}

static int cubrid_lob_write(int con_h_id, T_CCI_LOB lob, T_CCI_U_TYPE type, php_cubrid_int64_t start_pos, int length, const char *buf, T_CCI_ERROR *err_buf)
{
    return (type == CCI_U_TYPE_BLOB) ? 
        cci_blob_write(con_h_id, lob, start_pos, length, buf, err_buf) : 
        cci_clob_write(con_h_id, lob, start_pos, length, buf, err_buf);
}

static int cubrid_lob_read(int con_h_id, T_CCI_LOB lob, T_CCI_U_TYPE type, php_cubrid_int64_t start_pos, int length, char *buf, T_CCI_ERROR *err_buf)
{
    return (type == CCI_U_TYPE_BLOB) ?
        cci_blob_read(con_h_id, lob, start_pos, length, buf, err_buf) :
        cci_clob_read(con_h_id, lob, start_pos, length, buf, err_buf);
}

static int cubrid_lob_free(T_CCI_LOB lob, T_CCI_U_TYPE type)
{
    return (type == CCI_U_TYPE_BLOB) ?
        cci_blob_free(lob) : cci_clob_free(lob);
}

/* method learn from pdo */
static const char digit_vec[] = "0123456789";
static char *php_cubrid_int64_to_str(php_cubrid_int64_t i64 TSRMLS_DC)
{
    char buffer[65];
    char outbuf[65] = "";
    register char *p;
    long long_val;
    char *dst = outbuf;

    if (i64 < 0) {
        i64 = -i64;
        *dst++ = '-';
    }

    if (i64 == 0) {
        *dst++ = '0';
        *dst++ = '\0';
        return estrdup(outbuf);
    }

    p = &buffer[sizeof(buffer)-1];
    *p = '\0';

    while ((php_cubrid_uint64_t)i64 > (php_cubrid_uint64_t)LONG_MAX) {
        php_cubrid_uint64_t quo = (php_cubrid_uint64_t)i64 / (unsigned int)10;
        unsigned int rem = (unsigned int)(i64 - quo*10U);
        *--p = digit_vec[rem];
        i64 = (php_cubrid_int64_t)quo;
    }
    long_val = (long)i64;
    while (long_val != 0) {
        long quo = long_val / 10;
        *--p = digit_vec[(unsigned int)(long_val - quo * 10)];
        long_val = quo;
    }
    while ((*dst++ = *p++) != 0)
            ;
    *dst = '\0';
    return estrdup(outbuf);
}

static int cubrid_get_charset_internal(int conn, T_CCI_ERROR *error)
{
    char *query = "SELECT charset FROM db_root";
    char *buffer;

    int cubrid_retval = 0;
    int request_handle = 0;
    int ind, index = -1;

    if ((cubrid_retval = cci_prepare(conn, query, 0, error)) < 0) {
        goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    request_handle = cubrid_retval;

    if ((cubrid_retval = cci_execute(request_handle, CCI_EXEC_ASYNC, 0, error)) < 0) {
        goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    cubrid_retval = cci_cursor(request_handle, 1, CCI_CURSOR_CURRENT, error);
    if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
        goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    if ((cubrid_retval = cci_fetch(request_handle, error)) < 0) {
        goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    if ((cubrid_retval = cci_get_data(request_handle, 1, CCI_A_TYPE_STR, &buffer, &ind)) < 0) {
        goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    if (ind != -1) {
	index = atoi(buffer);
    } else {
	goto ERR_CUBRID_GET_CHARSET_INTERNAL;
    }

    if (index < 0 || index > MAX_DB_CHARSETS) {
	index = MAX_DB_CHARSETS;
    }

    cci_close_req_handle(request_handle);
    return index;

ERR_CUBRID_GET_CHARSET_INTERNAL:

    if (request_handle > 0) {
        cci_close_req_handle(request_handle);
    }

    return cubrid_retval;
}

static void php_cubrid_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long type, int is_object)
{
    zval *req_id = NULL, *ctor_params = NULL, *param = NULL;
    zend_class_entry *ce = NULL;

    T_CUBRID_REQUEST *request;
    T_CCI_ERROR error;
    int cubrid_retval = 0;

    init_error();

    if (is_object) {
        char *class_name = NULL;
        int class_name_len = 0;
        long tmp = 0;

        switch (ZEND_NUM_ARGS()) {
        case 1:
            if (zend_parse_parameters(1 TSRMLS_CC, "r", &req_id) == FAILURE) {
                return;
            }

            ce = zend_standard_class_def;
            break;

        case 2:
            if (zend_parse_parameters(2 TSRMLS_CC, "rz", &req_id, &param) == FAILURE) {
                return;
            }

            switch (Z_TYPE_P(param)) {
            case IS_STRING:
                class_name = Z_STRVAL_P(param);
                class_name_len = Z_STRLEN_P(param);

                ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);

                break;
            case IS_LONG:
                tmp = Z_LVAL_P(param);
                if (tmp & CUBRID_LOB) {
                    type |= CUBRID_LOB;
                }

                ce = zend_standard_class_def;

                break;
            default:
                return;
            }

            break;
        case 3:
            if (zend_parse_parameters(3 TSRMLS_CC, "rsz", &req_id, &class_name, &class_name_len, &param) == FAILURE) {
                return;
            }

            switch (Z_TYPE_P(param)) {
            case IS_LONG:
                tmp = Z_LVAL_P(param); 
                if (tmp & CUBRID_LOB) {
                    type |= CUBRID_LOB;
                }

                break;

            default:
                ctor_params = param;
            }

            ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);

            break;

        case 4:
            if (zend_parse_parameters(4 TSRMLS_CC, "rszl", 
                        &req_id, &class_name, &class_name_len, &ctor_params, &tmp) == FAILURE) {
                return;
            }

            ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);

            if (tmp & CUBRID_LOB) {
                type |= CUBRID_LOB;
            }

            break;

        default:
            return;
        }

        if (!ce) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not find class '%s'", class_name);
            return;
        }

    } else {

        long type2 = 0;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &req_id, &type2) == FAILURE) {
            return;
        }

        if (type2 == 0 && type == 0) {
            type = CUBRID_BOTH;
        } else if (type2 == CUBRID_LOB && type == 0) {
            type = CUBRID_BOTH | CUBRID_LOB;
        } else {
            type |= type2;
        }

        if (type & CUBRID_OBJECT) {
            type |= CUBRID_ASSOC;
        }
    }

    ZEND_FETCH_RESOURCE(request, T_CUBRID_REQUEST *, &req_id, -1, "CUBRID-Request", le_request);

    init_error_link(request->conn);

    if ((type & CUBRID_LOB) && (request->lob2_list == NULL)) {
        request->lob2_list = (T_CUBRID_LOB2 **) emalloc (sizeof(T_CUBRID_LOB2 *) * request->col_count);
        if (!request->lob2_list) {
            handle_error(CCI_ER_NO_MORE_MEMORY, NULL, request->conn);
            return;
        }
        memset(request->lob2_list, 0, sizeof(T_CUBRID_LOB2 *) * request->col_count);
    }

    cubrid_retval = cci_cursor(request->handle, 0, CCI_CURSOR_CURRENT, &error);
    if (cubrid_retval == CCI_ER_NO_MORE_DATA) {
        if (request->field_lengths != NULL) {
            efree (request->field_lengths);
            request->field_lengths = NULL;
        }

        if (request->lob2_list != NULL) {
            int i;
            for (i = 0; i < request->col_count; i++) {
                if (request->lob2_list[i]) {
                    request->lob2_list[i]->connect = NULL;
                    request->lob2_list[i] = NULL;
                }
            }
        }

        RETURN_FALSE;
    } else if (cubrid_retval < 0) {
        handle_error(cubrid_retval, &error, request->conn);
        return;
    }

    if ((cubrid_retval = cci_fetch(request->handle, &error)) < 0) {
        handle_error(cubrid_retval, &error, request->conn);
        return;
    }

    if ((cubrid_retval = fetch_a_row(return_value, request->conn, request->handle, request, type TSRMLS_CC)) != SUCCESS) {
        handle_error(cubrid_retval, NULL, request->conn);
        return;
    }

    if (is_object) {
        zval dataset = *return_value;
        zend_fcall_info fci;
        zend_fcall_info_cache fcc;
        zval *retval_ptr;

        object_and_properties_init(return_value, ce, NULL);
        zend_merge_properties(return_value, Z_ARRVAL(dataset), 1 TSRMLS_CC);

        if (ce->constructor) {
            fci.size = sizeof(fci);
            fci.function_table = &ce->function_table;
            fci.function_name = NULL;
            fci.symbol_table = NULL;
#if PHP_MINOR_VERSION < 3
            fci.object_pp = &return_value;
#else
            fci.object_ptr = return_value;
#endif
            fci.retval_ptr_ptr = &retval_ptr;

            if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
                if (Z_TYPE_P(ctor_params) == IS_ARRAY) {
                    HashTable *ht = Z_ARRVAL_P(ctor_params);
                    Bucket *p;

                    fci.param_count = 0;
                    fci.params = safe_emalloc(sizeof(zval*), ht->nNumOfElements, 0);
                    p = ht->pListHead;
                    while (p != NULL) {
                        fci.params[fci.param_count++] = (zval**)p->pData;
                        p = p->pListNext;
                    }
                } else {
                    zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Parameter ctor_params must be an array", 0 TSRMLS_CC);
                    return;
                }
            } else {
                fci.param_count = 0;
                fci.params = NULL;
            }

            fci.no_separation = 1;

            fcc.initialized = 1;
            fcc.function_handler = ce->constructor;
            fcc.calling_scope = EG(scope);
#if PHP_MINOR_VERSION < 3
            fcc.object_pp = &return_value;
#else
            fcc.called_scope = Z_OBJCE_P(return_value);
            fcc.object_ptr = return_value;
#endif

            if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
                zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, 
                        "Could not execute %s::%s()", ce->name, ce->constructor->common.function_name);
            } else {
                if (retval_ptr) {
                    zval_ptr_dtor(&retval_ptr);
                }
            }

            if (fci.params) {
                efree(fci.params);
            }
        } else if (ctor_params) {
            zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC,
                    "Class %s does not have a constructor hence you cannot use ctor_params", ce->name);
        }

        if (Z_TYPE_P(return_value) == IS_ARRAY) {
            object_and_properties_init(return_value, ZEND_STANDARD_CLASS_DEF_PTR, Z_ARRVAL_P(return_value));
        }
    }

    if (type & CUBRID_OBJECT) {
        if (return_value->type == IS_ARRAY) {
            convert_to_object(return_value);
        }
    }

    cubrid_retval = cci_cursor (request->handle, 1, CCI_CURSOR_CURRENT, &error);
    if (cubrid_retval < 0 && cubrid_retval != CCI_ER_NO_MORE_DATA) {
        handle_error(cubrid_retval, &error, request->conn);
        return;
    }
}

static void linked_list_append(LINKED_LIST *list, void *data)
{
    LINKED_LIST_NODE *new_node = (LINKED_LIST_NODE *) emalloc(sizeof(LINKED_LIST_NODE));

    if (!new_node) {
        return;
    }

    new_node->data = data;
    new_node->next = NULL;

    list->tail->next = new_node;
    list->tail = new_node;
}

static void linked_list_delete(LINKED_LIST *list, void *data)
{
    LINKED_LIST_NODE *p, *q;

    for (p = list->head, q = p->next; q != NULL; p = q, q = q->next) {
        if (q->data == data) {
            p->next = q->next;

            if (list->tail == q) {
                list->tail = p;
            }

            efree(q);
            break;
        }
    }
}