static NEOERR* pgsql_mdb_query_getv(mdb_conn* conn, const char* fmt, va_list ap) { PGresult* res = CONN(conn)->pg_res; int row_no = CONN(conn)->row_no; NEOERR *err = STATUS_OK; if (res == NULL) return nerr_raise(NERR_DB, "attemp fetch null res"); if (row_no >= mdb_get_rows(conn)) { if (row_no == 0) return nerr_raise(NERR_NOT_FOUND, "empty result"); return nerr_raise(NERR_OUTOFRANGE, "last row has fetched"); } int param_count = fmt != NULL ? strlen(fmt) : 0; int i, col = 0; for (i = 0; i < param_count; i++) { if (fmt[i] == 's') { char** str_ptr = (char**)va_arg(ap, char**); if (PQgetisnull(res, row_no, col)) *str_ptr = NULL; else *str_ptr = PQgetvalue(res, row_no, col); col++; } else if (fmt[i] == 'S') {
CPINLINE int CP_CLIENT_SERIALIZE_SEND_MEM(zval *ret_value, cpClient *cli) { int pipe_fd_write = get_writefd(CONN(cli)->worker_id); instead_smart dest; dest.len = 0; dest.addr = get_attach_buf(CONN(cli)->worker_id, CPGS->max_buffer_len, CPGS->G[CONN(cli)->group_id].workers[CONN(cli)->worker_index].sm_obj.mmap_name); dest.max = CPGS->max_buffer_len; dest.exceed = 0; php_msgpack_serialize(&dest, ret_value); if (dest.exceed == 1) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "data is exceed,increase max_read_len Error: %s [%d] ", strerror(errno), errno); } else { cpWorkerInfo worker_event; worker_event.len = dest.len; worker_event.pid = cpPid; worker_event.type = 0; //暫時沒用 int ret = write(pipe_fd_write, &worker_event, sizeof (worker_event)); if (ret == -1) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "write error Error: %s [%d]", strerror(errno), errno); } return SUCCESS; } return FAILURE; }
static NEOERR* mysql_mdb_query_getv(mdb_conn* conn, const char* fmt, va_list ap) { MYSQL_RES* res = CONN(conn)->res; MYSQL_ROW row = CONN(conn)->row; int row_no = CONN(conn)->row_no; NEOERR *err = STATUS_OK; if (res == NULL) return nerr_raise(NERR_DB, "attemp fetch null res"); if (row_no >= mdb_get_rows(conn)) { if (row_no == 0) return nerr_raise(NERR_NOT_FOUND, "empty result"); return nerr_raise(NERR_OUTOFRANGE, "last row has fetched"); } int param_count = fmt != NULL ? strlen(fmt) : 0; int i, col = 0; row = mysql_fetch_row(res); if (!row) return nerr_raise(NERR_OUTOFRANGE, "last row has fetched"); if (param_count > mysql_num_fields(res)) return nerr_raise(NERR_ASSERT, "result col num not match"); for (i = 0; i < param_count; i++) { if (fmt[i] == 's') { char** str_ptr = (char**)va_arg(ap, char**); if (row[col] == NULL) *str_ptr = NULL; else *str_ptr = row[col]; col++; } else if (fmt[i] == 'S') {
static NEOERR* mysql_mdb_rollback(mdb_conn* conn) { if (mysql_rollback(CONN(conn)->mysql) != 0) return nerr_raise(NERR_DB, mysql_error(CONN(conn)->mysql)); return STATUS_OK; }
static NEOERR* mysql_mdb_begin(mdb_conn* conn) { if (mysql_real_query(CONN(conn)->mysql, "BEGIN", strlen("BEGIN")) != 0) return nerr_raise(NERR_DB, mysql_error(CONN(conn)->mysql)); return STATUS_OK; }
static sdb_conn_t * mock_conn_create(void) { mock_conn_t *conn; conn = calloc(1, sizeof(*conn)); if (! conn) { fail("INTERNAL ERROR: failed to allocate connection object"); return NULL; } SDB_OBJ(conn)->name = "mock_connection"; SDB_OBJ(conn)->ref_cnt = 1; conn->conn.buf = sdb_strbuf_create(0); conn->conn.errbuf = sdb_strbuf_create(0); conn->write_buf = sdb_strbuf_create(64); if ((! conn->conn.buf) || (! conn->conn.errbuf) || (! conn->write_buf)) { mock_conn_destroy(CONN(conn)); fail("INTERNAL ERROR: failed to allocate connection object"); return NULL; } conn->conn.read = mock_conn_read; conn->conn.write = mock_conn_write; conn->conn.username = "******"; conn->conn.cmd = SDB_CONNECTION_IDLE; conn->conn.cmd_len = 0; return CONN(conn); } /* mock_conn_create */
static void pgsql_mdb_disconnect(mdb_conn* conn) { if (CONN(conn)->pg) PQfinish(CONN(conn)->pg); if (CONN(conn)->pg_res != NULL) PQclear(CONN(conn)->pg_res); CONN(conn)->pg_res = NULL; }
void IoEvConnection_free(IoEvConnection *self) { if (CONN(self)) { evhttp_connection_free(CONN(self)); IoObject_setDataPointer_(self, 0x0); } }
static NEOERR* pgsql_mdb_query_fill(mdb_conn* conn, const char* sql_string) { if (CONN(conn)->pg_res != NULL) PQclear(CONN(conn)->pg_res); CONN(conn)->pg_res = NULL; CONN(conn)->row_no = 0; if (conn->sql) free(conn->sql); conn->sql = NULL; if (sql_string) conn->sql = strdup(sql_string); return STATUS_OK; }
IoObject *IoEvConnection_connect(IoEvConnection *self, IoObject *locals, IoMessage *m) { IoEventManager *em = IoObject_getSlot_(self, IOSYMBOL("eventManager")); IoSeq *address = IoObject_seqGetSlot_(self, IOSYMBOL("address")); int port = IoObject_doubleGetSlot_(self, IOSYMBOL("port")); IOASSERT(CONN(self) == 0x0, "already have connection"); IOASSERT(ISEEVENTMANAGER(em), "eventManager slot not set properly"); //printf("IoEventManager_rawBase(em) = %p\n", (void *)IoEventManager_rawBase(em)); IoObject_setDataPointer_(self, evhttp_connection_new(CSTRING(address), port)); evhttp_connection_set_base(CONN(self), IoEventManager_rawBase(em)); evhttp_connection_set_closecb(CONN(self), IoEvConnection_ConnectionCloseCallback, self); return self; }
int main (int argc, char *argv[]) { MYSQL *mysql; MYSQL_RES *result; MYSQL_ROW row; my_bool reconnect = 0; mysql = mysql_init(NULL); mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect); CONN(0); MYSQL_STMT *stmt; MYSQL_BIND bind[7]; my_ulonglong affected_rows; int param_count; short small_data; int int_data; char str_data[STRING_SIZE]; unsigned long str_length; my_bool is_null; mysql_query(mysql, "select * from d limit 100000"); result = mysql_store_result(mysql); while(mysql_fetch_row(result)); mysql_close(mysql); }
ret_t cherokee_logger_write_access (cherokee_logger_t *logger, void *conn) { ret_t ret; /* Sanity check */ if (unlikely (logger->write_access == NULL)) { return ret_error; } /* Deal with X-Real-IP */ if (logger->priv->x_real_ip.enabled) { ret = parse_x_real_ip (logger, CONN(conn)); if (unlikely (ret == ret_error)) { return ret_error; } } /* Call the virtual method */ CHEROKEE_MUTEX_LOCK (&PRIV(logger)->mutex); ret = logger->write_access (logger, conn); CHEROKEE_MUTEX_UNLOCK (&PRIV(logger)->mutex); return ret; }
int main(int argc, char* argv[]) { MYSQL *mysql,*sock; MYSQL_ROW row; MYSQL_RES *result; mysql = mysql_init(NULL); if (!(sock = CONN(CLIENT_MULTI_STATEMENTS))) { fprintf(stderr, "Couldn't connect to engine!\n%s\n\n", mysql_error(mysql)); perror(""); exit(1); } char *sql = "select 1;select * from n"; mysql_query(sock, sql); do { printf("total affected rows: %lld\n", mysql_affected_rows(sock)); if (!(result= mysql_store_result(sock))) { printf("Got fatal error processing query\n"); exit(1); } row = mysql_fetch_row(result); printf("%s\n", row[0]); mysql_free_result(result); } while (!mysql_next_result(sock)); return 0; }
int main (int argc, char *argv[]) { MYSQL *mysql; MYSQL_RES *result; MYSQL_ROW row; my_bool reconnect = 0; mysql = mysql_init(NULL); mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect); CONN(0); MYSQL_STMT *stmt; MYSQL_BIND bind[7]; my_ulonglong affected_rows; int param_count; short small_data; int int_data; char str_data[STRING_SIZE]; unsigned long str_length; my_bool is_null; int id = mysql_query(mysql, SQL); result = mysql_store_result(mysql); printf("%d %d\n", id, mysql_errno(mysql)); if (result) while(mysql_fetch_row(result)) { printf("ok\n"); } mysql_close(mysql); }
ret_t cherokee_validator_check (cherokee_validator_t *validator, void *conn) { if (validator->check == NULL) { return ret_error; } return validator->check (validator, CONN(conn)); }
ret_t cherokee_validator_add_headers (cherokee_validator_t *validator, void *conn, cherokee_buffer_t *buf) { if (validator->add_headers == NULL) { return ret_error; } return validator->add_headers (validator, CONN(conn), buf); }
static NEOERR* pgsql_mdb_rollback(mdb_conn* conn) { PGresult* res; NEOERR *err = STATUS_OK; res = PQexec(CONN(conn)->pg, "ROLLBACK"); if (PQresultStatus(res) != PGRES_COMMAND_OK) err = nerr_raise(NERR_DB, PQresultErrorMessage(res)); PQclear(res); return err; }
int main() { int i,n,j,a[CON(SIZE)+1]={0}; n=(int)ceil(sqrt(SIZE));n=CON(n); for(i=0;i<n;i++) { if(a[i]==0) for(j=CON2(i);j<CON(SIZE);j+=ICON(i)) a[j]=1; } j=0; for(i=0;i<=CON(SIZE);i++) if(a[i]==0) { prime[j]=ICON(i); j++; } int t,m,f; scanf("%d",&t); while(t--) { int b[100010]={0},s=0; scanf("%d%d",&m,&n); if(m<=2)printf("2\n"),m=3; if(m%2==0)m++; if(n%2==0)n--; f=(int)sqrt(n); for(i=0;i<3401;i++) { if(prime[i]>f)break; int start; if(m>=prime[i]) { start=m+prime[i]-m%prime[i]; if(start%2==0)start+=prime[i]; start-=m; if(m%prime[i]==0 &&m!=prime[i])start=0; } else start=prime[i]*prime[i]-m; for(j=CONN(start);j<=(n-m)/2;j+=prime[i]) b[j]=1; } for(i=0;i<=(n-m)/2;i++) if(b[i]==0) // s++; printf("%d\n",ICON2(i)+m); // printf("%d\n",s); printf("\n"); } return 0; }
static void mysql_mdb_disconnect(mdb_conn* conn) { if (CONN(conn)->mysql != NULL) mysql_close(CONN(conn)->mysql); CONN(conn)->mysql = NULL; if (CONN(conn)->res != NULL) mysql_free_result(CONN(conn)->res); CONN(conn)->res = NULL; }
static SQLRETURN _SQLExecute_ConvParams (SQLHSTMT hstmt, BOOL bOutput) { STMT (pstmt, hstmt); CONN (pdbc, pstmt->hdbc); ENVR (penv, pdbc->henv); PPARM pparm; int maxpar; int i; SQLULEN j; SQLULEN cRows = pstmt->paramset_size; if (penv->unicode_driver) return SQL_SUCCESS; if (cRows == 0) cRows = 1; maxpar = pstmt->st_nparam; pparm = pstmt->st_pparam; for (i = 0; i < maxpar; i++, pparm++) { if (pparm->pm_data == NULL) continue; if (bOutput && (pparm->pm_usage == SQL_PARAM_OUTPUT || pparm->pm_usage == SQL_PARAM_INPUT_OUTPUT)) { if (pparm->pm_c_type_orig != SQL_C_WCHAR) continue; for (j = 0; j < cRows; j++) _ConvParam(pstmt, pparm, j, bOutput); } else if (!bOutput && (pparm->pm_usage == SQL_PARAM_INPUT || pparm->pm_usage == SQL_PARAM_INPUT_OUTPUT)) { if (pparm->pm_c_type != SQL_C_WCHAR) continue; for (j = 0; j < cRows; j++) _ConvParam(pstmt, pparm, j, bOutput); pparm->pm_c_type = SQL_C_CHAR; } } /* next column */ return SQL_SUCCESS; }
static void connection_destroy(sdb_object_t *obj) { sdb_conn_t *conn; size_t len; assert(obj); conn = CONN(obj); conn->ready = 0; if (conn->finish) conn->finish(conn); conn->finish = NULL; if (conn->buf) { len = sdb_strbuf_len(conn->buf); if (len) sdb_log(SDB_LOG_INFO, "frontend: Discarding incomplete command " "(%zu byte%s left in buffer)", len, len == 1 ? "" : "s"); } if (conn->client_addr.ss_family == AF_UNIX) { sdb_log(SDB_LOG_DEBUG, "frontend: Closing connection %s from peer %s", obj->name, conn->username); } else { char host[1024] = "<unknown>", port[32] = ""; getnameinfo((struct sockaddr *)&conn->client_addr, conn->client_addr_len, host, sizeof(host), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV); sdb_log(SDB_LOG_DEBUG, "frontend: Closing connection %s from peer %s " "at %s:%s", obj->name, conn->username, host, port); } sdb_connection_close(conn); if (conn->username) free(conn->username); conn->username = NULL; sdb_strbuf_destroy(conn->buf); conn->buf = NULL; sdb_strbuf_destroy(conn->errbuf); conn->errbuf = NULL; } /* connection_destroy */
ret_t cherokee_post_read_header (cherokee_post_t *post, void *cnt) { ret_t ret; char *info = NULL; cuint_t info_len = 0; cherokee_connection_t *conn = CONN(cnt); switch (post->read_header_phase) { case cherokee_post_read_header_init: /* Read the header */ ret = parse_header (post, conn); if (unlikely (ret != ret_ok)) { return ret; } post->has_info = true; ret = remove_surplus (post, conn); if (unlikely (ret != ret_ok)) { return ret; } /* Expect: 100-continue * http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html */ ret = cherokee_header_get_known (&conn->header, header_expect, &info, &info_len); if (likely (ret != ret_ok)) { return ret_ok; } cherokee_buffer_add_str (&post->read_header_100cont, HTTP_100_RESPONSE); post->read_header_phase = cherokee_post_read_header_100cont; case cherokee_post_read_header_100cont: return reply_100_continue (post, conn); } SHOULDNT_HAPPEN; return ret_error; }
static void* connect_pool_perisent(zval* zres, zval* data_source) { // cpLog_init("/tmp/pool_client.log"); zend_rsrc_list_entry sock_le; int ret; cpClient* cli = (cpClient*) pecalloc(sizeof (cpClient), 1, 1); if (cpClient_create(cli) < 0) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "pdo_connect_pool: create sock fail. Error: %s [%d]", strerror(errno), errno); } ret = cpClient_connect(cli, "127.0.0.1", 6253, (float) 100, 0); //所有的操作100s超时 if (ret < 0) { pefree(cli, 1); return NULL; } sock_le.type = le_cli_connect_pool; sock_le.ptr = cli; ZEND_REGISTER_RESOURCE(zres, cli, le_cli_connect_pool); zend_hash_update(&EG(persistent_list), Z_STRVAL_P(data_source), Z_STRLEN_P(data_source), (void*) &sock_le, sizeof (zend_rsrc_list_entry), NULL); cli->lock = cpMutexLock; cli->unLock = cpMutexUnLock; cpTcpEvent event = {0}; event.type = CP_TCPEVENT_GETFD; cpClient_send(cli->sock, (char *) &event, sizeof (event), 0); cpMasterInfo info; ret = cpClient_recv(cli->sock, &info, sizeof (cpMasterInfo), 1); if (ret < 0) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "recv from pool server error [%d],%s", errno, strerror(errno)); } cli->server_fd = info.server_fd; cpClient_attach_mem(); CONN(cli)->release = CP_FD_RELEASED; return cli; }
int main(int argc, char* argv[]) { MYSQL *mysql,*sock; MYSQL_ROW row; MYSQL_RES *result; mysql = mysql_init(NULL); if (!(sock = CONN(0))) { fprintf(stderr, "Couldn't connect to engine!\n%s\n\n", mysql_error(mysql)); perror(""); exit(1); } // simple char sql[100] = {}; sprintf(sql, "INSERT INTO blob_test(a, b) VALUE (1, 2)"); mysql_query(sock, sql); mysql_query(sock, "select * from blob_test"); result = mysql_store_result(mysql); mysql_free_result(result); #define INSERT_QUERY "INSERT INTO blob_test(a, b) VALUES(?,?)" MYSQL_STMT *stmt; MYSQL_BIND bind[2]; long length; int int_data = 10; char str[100]; int ret; stmt = mysql_stmt_init(mysql); mysql_stmt_prepare(stmt, INSERT_QUERY, strlen(INSERT_QUERY)); memset(bind, 0, sizeof(bind)); bind[0].buffer_type= MYSQL_TYPE_LONG; bind[0].buffer= (char *)&int_data; bind[0].is_null= 0; bind[1].buffer_type= MYSQL_TYPE_BLOB; bind[1].buffer = (char*)&str; bind[1].is_null= 0; mysql_stmt_bind_param(stmt, bind); ret = mysql_stmt_send_long_data(stmt,1,"fails",5); ret = mysql_stmt_send_long_data(stmt,1," - The most popular Open Source database",40); mysql_stmt_execute(stmt); mysql_stmt_close(stmt); stmt = mysql_stmt_init(mysql); mysql_stmt_prepare(stmt, INSERT_QUERY, strlen(INSERT_QUERY)); size_t s = sizeof(str); memset(bind, 0, sizeof(bind)); bind[0].buffer_type= MYSQL_TYPE_LONG; bind[0].buffer= (char *)&int_data; bind[0].is_null= 0; bind[1].buffer_type= MYSQL_TYPE_BLOB; bind[1].buffer = (char*)&str; bind[1].is_null= 0; bind[1].length= (char*)&s; mysql_stmt_bind_param(stmt, bind); snprintf(str, sizeof(str), "%s", "this success"); mysql_stmt_execute(stmt); mysql_stmt_close(stmt); return 0; }
CPINLINE cpGroup * cpGet_worker(cpClient *cli, zval **data_source) { cpGroup *G = NULL; int group_id, worker_index; for (group_id = 0; group_id < CPGS->group_num; group_id++) { if (strcmp(Z_STRVAL_PP(data_source), CPGS->G[group_id].name) == 0) { G = &CPGS->G[group_id]; cpConnection *conn = CONN(cli); if (cli->lock(G) == 0) { for (worker_index = 0; worker_index < G->worker_num; worker_index++) { if (G->workers_status[worker_index] == CP_WORKER_IDLE && worker_index < G->worker_max) { G->workers_status[worker_index] = CP_WORKER_BUSY; G->workers[worker_index].CPid = cpPid; //worker for this pid conn->release = CP_FD_NRELEASED; conn->worker_id = group_id * CP_GROUP_LEN + worker_index; conn->group_id = group_id; conn->worker_index = worker_index; break; } } if (conn->release == CP_FD_RELEASED) { if (G->worker_num < G->worker_max) {//add conn->worker_index = G->worker_num; conn->release = CP_FD_NRELEASED; conn->worker_id = group_id * CP_GROUP_LEN + conn->worker_index; conn->group_id = group_id; G->workers_status[conn->worker_index] = CP_WORKER_BUSY; G->workers[conn->worker_index].CPid = cpPid; //worker for this pid cpCreate_worker_mem(conn->worker_index, group_id); cpTcpEvent event = {0}; event.type = CP_TCPEVENT_ADD; event.data = conn->worker_index; // event.ClientPid = cpPid; G->worker_num++; //add first, for thread safe int ret = cpClient_send(cli->sock, (char *) &event, sizeof (event), 0); if (ret < 0) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "send to server errro %s [%d]", strerror(errno), errno); } } else {// in queue conn->wait_fpm_pid = cpPid; conn->next_wait_id = 0; if (G->last_wait_id) { CPGS->conlist[G->last_wait_id].next_wait_id = cli->server_fd; G->last_wait_id = cli->server_fd; } else { G->first_wait_id = G->last_wait_id = cli->server_fd; } conn->release = CP_FD_WAITING; conn->group_id = group_id; } } cli->unLock(G); } break; } } return G; }
/*! For 3D and 2D. @par Revision history: - 08.06.2006, c - 02.08.2006 */ int32 orient_elements( int32 *flag, int32 flag_n_row, int32 *conn, int32 conn_n_row, int32 conn_n_col, float64 *coors, int32 coors_n_row, int32 coors_n_col, int32 *v_roots, int32 v_roots_n_row, int32 *v_vecs, int32 v_vecs_n_row, int32 v_vecs_n_col, int32 *swap_from, int32 swap_from_n_row, int32 swap_from_n_col, int32 *swap_to, int32 swap_to_n_row, int32 swap_to_n_col ) { #define IR( iel, ir ) (conn[conn_n_col*(iel)+v_roots[ir]]) #define IV( iel, ir, iv ) (conn[conn_n_col*(iel)+v_vecs[v_vecs_n_col*ir+iv]]) #define CONN( iel, ip ) (conn[conn_n_col*(iel)+ip]) #define SWF( ir, is ) (swap_from[swap_from_n_col*ir+is]) #define SWT( ir, is ) (swap_to[swap_to_n_col*ir+is]) int32 ir, iel, ii, ip0, ip1, ip2, ip3, tmp, nc; float64 v0[3], v1[3], v2[3], v3[3], cross[3], dot[1]; nc = coors_n_col; if (nc == 4) { // 3D. for (iel = 0; iel < conn_n_row; iel++) { flag[iel] = 0; for (ir = 0; ir < v_roots_n_row; ir++) { ip0 = IR( iel, ir ); ip1 = IV( iel, ir, 0 ); ip2 = IV( iel, ir, 1 ); ip3 = IV( iel, ir, 2 ); for (ii = 0; ii < 3; ii++) { v0[ii] = coors[nc*ip0+ii]; v1[ii] = coors[nc*ip1+ii] - v0[ii]; v2[ii] = coors[nc*ip2+ii] - v0[ii]; v3[ii] = coors[nc*ip3+ii] - v0[ii]; } gtr_cross_product( cross, v1, v2 ); gtr_dot_v3( dot, v3, cross ); /* output( "%d %d -> %d %d %d %d %e\n", iel, ir, ip0, ip1, ip2, ip3, */ /* dot[0] ); */ if (dot[0] < CONST_MachEps) { flag[iel]++; for (ii = 0; ii < swap_from_n_col; ii++) { SwapValues( CONN( iel, SWF( ir, ii ) ), CONN( iel, SWT( ir, ii ) ), tmp ); /* output( "%d %d\n", SWF( ir, ii ), SWT( ir, ii ) ); */ } } } /* sys_pause(); */ } } else if (nc == 3) { // 2D. for (iel = 0; iel < conn_n_row; iel++) { flag[iel] = 0; for (ir = 0; ir < v_roots_n_row; ir++) { ip0 = IR( iel, ir ); ip1 = IV( iel, ir, 0 ); ip2 = IV( iel, ir, 1 ); for (ii = 0; ii < 2; ii++) { v0[ii] = coors[nc*ip0+ii]; v1[ii] = coors[nc*ip1+ii] - v0[ii]; v2[ii] = coors[nc*ip2+ii] - v0[ii]; } v1[2] = v2[2] = 0.0; gtr_cross_product( cross, v1, v2 ); if (cross[2] < CONST_MachEps) { flag[iel]++; for (ii = 0; ii < swap_from_n_col; ii++) { SwapValues( CONN( iel, SWF( ir, ii ) ), CONN( iel, SWT( ir, ii ) ), tmp ); } } } } } return( RET_OK ); #undef IR #undef IV #undef CONN #undef SWF #undef SWT }
SQLRETURN SQL_API SQLPrepare_Internal ( SQLHSTMT hstmt, SQLPOINTER szSqlStr, SQLINTEGER cbSqlStr, SQLCHAR waMode) { STMT (pstmt, hstmt); CONN (pdbc, pstmt->hdbc); ENVR (penv, pdbc->henv); HPROC hproc = SQL_NULL_HPROC; SQLRETURN retcode = SQL_SUCCESS; sqlstcode_t sqlstat = en_00000; void * _SqlStr = NULL; /* check state */ if (pstmt->asyn_on == en_NullProc) { /* not on asyn state */ switch (pstmt->state) { case en_stmt_fetched: case en_stmt_xfetched: sqlstat = en_24000; break; case en_stmt_needdata: case en_stmt_mustput: case en_stmt_canput: sqlstat = en_S1010; break; default: break; } } else if (pstmt->asyn_on != en_Prepare) { /* asyn on other */ sqlstat = en_S1010; } if (sqlstat != en_00000) { PUSHSQLERR (pstmt->herr, sqlstat); return SQL_ERROR; } if (szSqlStr == NULL) { PUSHSQLERR (pstmt->herr, en_S1009); return SQL_ERROR; } if (cbSqlStr < 0 && cbSqlStr != SQL_NTS) { PUSHSQLERR (pstmt->herr, en_S1090); return SQL_ERROR; } if ((penv->unicode_driver && waMode != 'W') || (!penv->unicode_driver && waMode == 'W')) { if (waMode != 'W') { /* ansi=>unicode*/ _SqlStr = _iodbcdm_conv_var_A2W(pstmt, 0, (SQLCHAR *) szSqlStr, cbSqlStr); } else { /* unicode=>ansi*/ _SqlStr = _iodbcdm_conv_var_W2A(pstmt, 0, (SQLWCHAR *) szSqlStr, cbSqlStr); } szSqlStr = _SqlStr; cbSqlStr = SQL_NTS; } CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver, en_Prepare, ( pstmt->dhstmt, szSqlStr, cbSqlStr)); if (hproc == SQL_NULL_HPROC) { _iodbcdm_FreeStmtVars(pstmt); PUSHSQLERR (pstmt->herr, en_IM001); return SQL_ERROR; } if (retcode != SQL_STILL_EXECUTING) _iodbcdm_FreeStmtVars(pstmt); /* stmt state transition */ if (pstmt->asyn_on == en_Prepare) { switch (retcode) { case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: case SQL_ERROR: pstmt->asyn_on = en_NullProc; return retcode; case SQL_STILL_EXECUTING: default: return retcode; } } switch (retcode) { case SQL_STILL_EXECUTING: pstmt->asyn_on = en_Prepare; break; case SQL_SUCCESS: case SQL_SUCCESS_WITH_INFO: pstmt->state = en_stmt_prepared; pstmt->prep_state = 1; break; case SQL_ERROR: switch (pstmt->state) { case en_stmt_prepared: case en_stmt_executed_with_info: case en_stmt_executed: pstmt->state = en_stmt_allocated; pstmt->prep_state = 0; break; default: break; } default: break; } return retcode; }
static SQLRETURN SQLSetScrollOptions_Internal ( SQLHSTMT hstmt, SQLUSMALLINT fConcurrency, SQLLEN crowKeyset, SQLUSMALLINT crowRowset) { STMT (pstmt, hstmt); CONN (pdbc, pstmt->hdbc); HPROC hproc = SQL_NULL_HPROC; sqlstcode_t sqlstat = en_00000; SQLRETURN retcode = SQL_SUCCESS; SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver; SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver; for (;;) { if (crowRowset == (UWORD) 0) { sqlstat = en_S1107; break; } if (crowKeyset > (SDWORD) 0L && crowKeyset < (SDWORD) crowRowset) { sqlstat = en_S1107; break; } if (crowKeyset < 1) { if (crowKeyset != SQL_SCROLL_FORWARD_ONLY && crowKeyset != SQL_SCROLL_STATIC && crowKeyset != SQL_SCROLL_KEYSET_DRIVEN && crowKeyset != SQL_SCROLL_DYNAMIC) { sqlstat = en_S1107; break; } } if (fConcurrency != SQL_CONCUR_READ_ONLY && fConcurrency != SQL_CONCUR_LOCK && fConcurrency != SQL_CONCUR_ROWVER && fConcurrency != SQL_CONCUR_VALUES) { sqlstat = en_S1108; break; } #if (ODBCVER < 0x0300) if (pstmt->state != en_stmt_allocated) { sqlstat = en_S1010; break; } #endif hproc = _iodbcdm_getproc (pstmt->hdbc, en_SetScrollOptions); if (dodbc_ver == SQL_OV_ODBC3 && odbc_ver == SQL_OV_ODBC3) hproc = SQL_NULL_HPROC; if (hproc != SQL_NULL_HPROC) { CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc, (pstmt->dhstmt, fConcurrency, crowKeyset, crowRowset)); } else { #if (ODBCVER >= 0x0300) SQLINTEGER InfoValue, InfoType, Value; HPROC hproc1 = _iodbcdm_getproc (pstmt->hdbc, en_SetStmtAttr); HPROC hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_GetInfo); if (hproc1 == SQL_NULL_HPROC || hproc2 == SQL_NULL_HPROC) { PUSHSQLERR (pstmt->herr, en_IM001); return SQL_ERROR; } switch (crowKeyset) { case SQL_SCROLL_FORWARD_ONLY: InfoType = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2; Value = SQL_CURSOR_FORWARD_ONLY; break; case SQL_SCROLL_STATIC: InfoType = SQL_STATIC_CURSOR_ATTRIBUTES2; Value = SQL_CURSOR_STATIC; break; case SQL_SCROLL_DYNAMIC: InfoType = SQL_DYNAMIC_CURSOR_ATTRIBUTES2; Value = SQL_CURSOR_DYNAMIC; break; case SQL_SCROLL_KEYSET_DRIVEN: default: InfoType = SQL_KEYSET_CURSOR_ATTRIBUTES2; Value = SQL_CURSOR_KEYSET_DRIVEN; break; } CALL_DRIVER (pstmt->hdbc, pdbc, retcode, hproc2, (pdbc->dhdbc, InfoType, &InfoValue, 0, NULL)); if (retcode != SQL_SUCCESS) { return retcode; } switch (fConcurrency) { case SQL_CONCUR_READ_ONLY: if (!(InfoValue & SQL_CA2_READ_ONLY_CONCURRENCY)) { PUSHSQLERR (pstmt->herr, en_S1C00); return SQL_ERROR; } break; case SQL_CONCUR_LOCK: if (!(InfoValue & SQL_CA2_LOCK_CONCURRENCY)) { PUSHSQLERR (pstmt->herr, en_S1C00); return SQL_ERROR; } break; case SQL_CONCUR_ROWVER: if (!(InfoValue & SQL_CA2_OPT_ROWVER_CONCURRENCY)) { PUSHSQLERR (pstmt->herr, en_S1C00); return SQL_ERROR; } break; case SQL_CONCUR_VALUES: if (!(InfoValue & SQL_CA2_OPT_VALUES_CONCURRENCY)) { PUSHSQLERR (pstmt->herr, en_S1C00); return SQL_ERROR; } break; } CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1, (pstmt->dhstmt, SQL_ATTR_CURSOR_TYPE, Value, 0)); if (retcode != SQL_SUCCESS) return retcode; CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1, (pstmt->dhstmt, SQL_ATTR_CONCURRENCY, fConcurrency, 0)); if (retcode != SQL_SUCCESS) return retcode; if (crowKeyset > 0) { CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1, (pstmt->dhstmt, SQL_ATTR_KEYSET_SIZE, crowKeyset, 0)); if (retcode != SQL_SUCCESS) return retcode; } CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1, (pstmt->dhstmt, SQL_ROWSET_SIZE, crowRowset, 0)); if (retcode != SQL_SUCCESS) return retcode; #else sqlstat = en_IM001; break; #endif } sqlstat = en_00000; if (1) /* turn off solaris warning message */ break; } if (sqlstat != en_00000) { PUSHSQLERR (pstmt->herr, sqlstat); return SQL_ERROR; } return retcode; }
static SQLRETURN SQLParamOptions_Internal ( SQLHSTMT hstmt, SQLULEN crow, SQLULEN * pirow) { STMT (pstmt, hstmt); HPROC hproc2 = SQL_NULL_HPROC; HPROC hproc3 = SQL_NULL_HPROC; SQLRETURN retcode; CONN (pdbc, pstmt->hdbc); SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver; SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver; if (crow == (SQLULEN) 0UL) { PUSHSQLERR (pstmt->herr, en_S1107); return SQL_ERROR; } if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc) { PUSHSQLERR (pstmt->herr, en_S1010); return SQL_ERROR; } hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_ParamOptions); #if (ODBCVER >= 0x0300) hproc3 = _iodbcdm_getproc (pstmt->hdbc, en_SetStmtAttr); #endif if (odbc_ver == SQL_OV_ODBC2 && ( dodbc_ver == SQL_OV_ODBC2 || (dodbc_ver == SQL_OV_ODBC3 && hproc2 != SQL_NULL_HPROC))) hproc3 = SQL_NULL_HPROC; #if (ODBCVER >= 0x0300) if (hproc3 != SQL_NULL_HPROC) { CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3, (pstmt->dhstmt, SQL_ATTR_PARAMSET_SIZE, crow, 0)); if (SQL_SUCCEEDED (retcode)) { CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3, (pstmt->dhstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, pirow, 0)); } } else #endif { if (hproc2 == SQL_NULL_HPROC) { PUSHSQLERR (pstmt->herr, en_IM001); return SQL_ERROR; } CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc2, (pstmt->dhstmt, crow, pirow)); } pstmt->paramset_size = crow; return retcode; }
static SQLRETURN SQLBindParameter_Internal ( SQLHSTMT hstmt, SQLUSMALLINT ipar, SQLSMALLINT fParamType, SQLSMALLINT fCType, SQLSMALLINT fSqlType, SQLULEN cbColDef, SQLSMALLINT ibScale, SQLPOINTER rgbValue, SQLLEN cbValueMax, SQLLEN * pcbValue) { STMT (pstmt, hstmt); CONN (pdbc, pstmt->hdbc); ENVR (penv, pdbc->henv); HPROC hproc2 = SQL_NULL_HPROC; HPROC hproc3 = SQL_NULL_HPROC; SQLSMALLINT nCType; SQLSMALLINT nSqlType; sqlstcode_t sqlstat = en_00000; SQLRETURN retcode = SQL_SUCCESS; SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver; SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver; PPARM newparam; TPARM parm; int size; #if (ODBCVER >= 0x0300) if (0) #else /* check param */ if (fSqlType > SQL_TYPE_MAX || (fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START)) /* Note: SQL_TYPE_DRIVER_START is a negative number * So, we use ">" */ #endif { sqlstat = en_S1004; } else if (ipar < 1) { sqlstat = en_S1093; } else if ((rgbValue == NULL && pcbValue == NULL) && fParamType != SQL_PARAM_OUTPUT) { sqlstat = en_S1009; /* This means, I allow output to nowhere * (i.e. * junk output result). But I can't * allow input from nowhere. */ } /********** else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX ) { sqlstat = en_S1090; } **********/ else if (fParamType != SQL_PARAM_INPUT && fParamType != SQL_PARAM_OUTPUT && fParamType != SQL_PARAM_INPUT_OUTPUT) { sqlstat = en_S1105; } else { switch (fCType) { case SQL_C_DEFAULT: case SQL_C_BINARY: case SQL_C_BIT: case SQL_C_CHAR: case SQL_C_DATE: case SQL_C_DOUBLE: case SQL_C_FLOAT: case SQL_C_LONG: case SQL_C_SHORT: case SQL_C_SLONG: case SQL_C_SSHORT: case SQL_C_STINYINT: case SQL_C_TIME: case SQL_C_TIMESTAMP: case SQL_C_TINYINT: case SQL_C_ULONG: case SQL_C_USHORT: case SQL_C_UTINYINT: #if (ODBCVER >= 0x0300) case SQL_C_GUID: case SQL_C_INTERVAL_DAY: case SQL_C_INTERVAL_DAY_TO_HOUR: case SQL_C_INTERVAL_DAY_TO_MINUTE: case SQL_C_INTERVAL_DAY_TO_SECOND: case SQL_C_INTERVAL_HOUR: case SQL_C_INTERVAL_HOUR_TO_MINUTE: case SQL_C_INTERVAL_HOUR_TO_SECOND: case SQL_C_INTERVAL_MINUTE: case SQL_C_INTERVAL_MINUTE_TO_SECOND: case SQL_C_INTERVAL_MONTH: case SQL_C_INTERVAL_SECOND: case SQL_C_INTERVAL_YEAR: case SQL_C_INTERVAL_YEAR_TO_MONTH: case SQL_C_NUMERIC: case SQL_C_SBIGINT: case SQL_C_TYPE_DATE: case SQL_C_TYPE_TIME: case SQL_C_TYPE_TIMESTAMP: case SQL_C_UBIGINT: case SQL_C_WCHAR: #endif break; default: sqlstat = en_S1003; break; } } if (sqlstat != en_00000) { PUSHSQLERR (pstmt->herr, sqlstat); return SQL_ERROR; } /* check state */ if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc) { PUSHSQLERR (pstmt->herr, en_S1010); retcode = SQL_ERROR; } /* * Convert C type to ODBC version of driver */ nCType = _iodbcdm_map_c_type (fCType, penv->dodbc_ver); /* * Convert SQL type to ODBC version of driver */ nSqlType = _iodbcdm_map_sql_type (fSqlType, penv->dodbc_ver); hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_BindParameter); #if (ODBCVER >=0x0300) hproc3 = _iodbcdm_getproc (pstmt->hdbc, en_BindParam); #endif parm.pm_par = ipar; parm.pm_c_type = nCType; parm.pm_c_type_orig = nCType; parm.pm_sql_type = fSqlType; parm.pm_precision = cbColDef; parm.pm_scale = ibScale; parm.pm_data = rgbValue; parm.pm_pOctetLength = pcbValue; parm.pm_pInd = pcbValue; parm.pm_size = size; parm.pm_usage = fParamType; parm.pm_cbValueMax = cbValueMax; #if (ODBCVER >=0x0300) if (fCType == SQL_C_WCHAR && !penv->unicode_driver && pcbValue && *pcbValue != SQL_DATA_AT_EXEC) nCType = SQL_C_CHAR; #endif if (ipar < 1 || ipar > STMT_MAX_PARAM) { PUSHSQLERR (pstmt->herr, en_S1093); return SQL_ERROR; } if (ipar > pstmt->st_nparam) { size_t newsize = ipar + 10; if (newsize > STMT_MAX_PARAM) newsize = STMT_MAX_PARAM; if ((newparam = calloc (newsize, sizeof (TPARM))) == NULL) { PUSHSQLERR (pstmt->herr, en_S1001); return SQL_ERROR; } if (pstmt->st_pparam) { memcpy (newparam, pstmt->st_pparam, pstmt->st_nparam * sizeof (TPARM)); free (pstmt->st_pparam); } pstmt->st_pparam = newparam; pstmt->st_nparam = (u_short) newsize; } pstmt->st_pparam[ipar-1] = parm; if (odbc_ver == SQL_OV_ODBC2 && ( dodbc_ver == SQL_OV_ODBC2 || (dodbc_ver == SQL_OV_ODBC3 && hproc2 != SQL_NULL_HPROC))) hproc3 = SQL_NULL_HPROC; #if (ODBCVER >=0x0300) if (fParamType == SQL_PARAM_INPUT && hproc3 != SQL_NULL_HPROC) { CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3, (pstmt->dhstmt, ipar, nCType, nSqlType, cbColDef, ibScale, rgbValue, pcbValue)); } else #endif { if (hproc2 == SQL_NULL_HPROC) { PUSHSQLERR (pstmt->herr, en_IM001); return SQL_ERROR; } CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc2, (pstmt->dhstmt, ipar, fParamType, nCType, nSqlType, cbColDef, ibScale, rgbValue, cbValueMax, pcbValue)); } return retcode; }