void PrepareDbTime() { OCIBind *bndv1 = 0; OCIBind *bndv2 = 0; static text *stmt_cputime = (text *) "begin :cpu_time_value := dbms_utility.get_cpu_time(); end;" ; static text *stmt_elptime = (text *) "begin :elp_time_value := dbms_utility.get_time(); end;" ; /* Allocate cpu time handle */ CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmt_cputimehp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0)); /* Allocate elapsed time handle */ CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmt_elptimehp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0)); /* Prepare cpu time statement */ CheckErr(errhp, OCIStmtPrepare(stmt_cputimehp, errhp, (CONST text *) stmt_cputime, strlen((char *) stmt_cputime), OCI_NTV_SYNTAX, OCI_DEFAULT)); /* Prepare elapsed time statement */ CheckErr(errhp, OCIStmtPrepare(stmt_elptimehp, errhp, (CONST text *) stmt_elptime, strlen((char *) stmt_elptime), OCI_NTV_SYNTAX, OCI_DEFAULT)); /* Bind cpu_time_value variable */ CheckErr(errhp, OCIBindByName(stmt_cputimehp, (OCIBind **) &bndv1, errhp, (text *)":cpu_time_value", (sb4) 15, &cpu_time_value, (sb4) sizeof(ub4), SQLT_INT, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT)); /* Bind elp_time_value variable */ CheckErr(errhp, OCIBindByName(stmt_elptimehp, (OCIBind **) &bndv2, errhp, (text *)":elp_time_value", (sb4) 15, &elp_time_value, (sb4) sizeof(ub4), SQLT_INT, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT)); }
sword AllocateHandles(ub1 mymem) { if (OCIEnvCreate(&envhp, (ub4) OCI_DEFAULT, (dvoid *)0, (dvoid * (*)(dvoid *, size_t)) 0, (dvoid * (*)(dvoid *, dvoid *, size_t))0, (void (*)(dvoid *, dvoid *)) 0, 0, (dvoid **) 0) != OCI_SUCCESS) { return OCI_ERROR; } /* allocate an error handle withtin the environment */ if (OCIHandleAlloc((dvoid *) envhp, (dvoid **) &errhp, (ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0)) { printf("OCIHandleAlloc failed for errhp\n"); return OCI_ERROR; } /* allocate a service context handle within the environment */ if (OCIHandleAlloc((dvoid *) envhp, (dvoid **) &svchp , (ub4) OCI_HTYPE_SVCCTX, (size_t) 0, (dvoid **) 0)) { printf("OCIHandleAlloc failed for context\n"); return OCI_ERROR; } return OCI_SUCCESS; }
static int _doConnect(T C, URL_T url, char** error) { #undef ERROR #define ERROR(e) do {*error = Str_dup(e); return false;} while (0) #define ORAERROR(e) do{ *error = Str_dup(OracleConnection_getLastError(e)); return false;} while(0) const char *database, *username, *password; const char *host = URL_getHost(url); int port = URL_getPort(url); if (! (username = URL_getUser(url))) if (! (username = URL_getParameter(url, "user"))) ERROR("no username specified in URL"); if (! (password = URL_getPassword(url))) if (! (password = URL_getParameter(url, "password"))) ERROR("no password specified in URL"); if (! (database = URL_getPath(url))) ERROR("no database specified in URL"); ++database; /* Create a thread-safe OCI environment with N' substitution turned on. */ if (OCIEnvCreate(&C->env, OCI_THREADED | OCI_OBJECT | OCI_NCHAR_LITERAL_REPLACE_ON, 0, 0, 0, 0, 0, 0)) ERROR("Create a OCI environment failed"); /* allocate an error handle */ if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->err, OCI_HTYPE_ERROR, 0, 0)) ERROR("Allocating error handler failed"); /* server contexts */ if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->srv, OCI_HTYPE_SERVER, 0, 0)) ERROR("Allocating server context failed"); /* allocate a service handle */ if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->svc, OCI_HTYPE_SVCCTX, 0, 0)) ERROR("Allocating service handle failed"); StringBuffer_clear(C->sb); /* Oracle connect string is on the form: //host[:port]/service name */ if (host) { StringBuffer_append(C->sb, "//%s", host); if (port > 0) StringBuffer_append(C->sb, ":%d", port); StringBuffer_append(C->sb, "/%s", database); } else /* Or just service name */ StringBuffer_append(C->sb, "%s", database); /* Create a server context */ C->lastError = OCIServerAttach(C->srv, C->err, StringBuffer_toString(C->sb), StringBuffer_length(C->sb), 0); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); /* Set attribute server context in the service context */ C->lastError = OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, C->srv, 0, OCI_ATTR_SERVER, C->err); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); C->lastError = OCIHandleAlloc(C->env, (void**)&C->usr, OCI_HTYPE_SESSION, 0, NULL); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); C->lastError = OCIAttrSet(C->usr, OCI_HTYPE_SESSION, (dvoid *)username, (int)strlen(username), OCI_ATTR_USERNAME, C->err); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); C->lastError = OCIAttrSet(C->usr, OCI_HTYPE_SESSION, (dvoid *)password, (int)strlen(password), OCI_ATTR_PASSWORD, C->err); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); C->lastError = OCISessionBegin(C->svc, C->err, C->usr, OCI_CRED_RDBMS, OCI_DEFAULT); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) ORAERROR(C); OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, C->usr, 0, OCI_ATTR_SESSION, C->err); return true; }
/* * call-seq: * allocate_handles() * * <b>internal use only</b> * * Allocates a service context handle, a session handle and a * server handle to use explicit attach and begin-session calls. */ static VALUE oci8_allocate_handles(VALUE self) { oci8_svcctx_t *svcctx = DATA_PTR(self); sword rv; if (svcctx->logoff_strategy != NULL) { rb_raise(rb_eRuntimeError, "Could not reuse the session."); } svcctx->logoff_strategy = &complex_logoff; svcctx->state = 0; /* allocate a service context handle */ rv = OCIHandleAlloc(oci8_envhp, &svcctx->base.hp.ptr, OCI_HTYPE_SVCCTX, 0, 0); if (rv != OCI_SUCCESS) oci8_env_raise(oci8_envhp, rv); svcctx->base.type = OCI_HTYPE_SVCCTX; /* alocalte a session handle */ rv = OCIHandleAlloc(oci8_envhp, (void*)&svcctx->usrhp, OCI_HTYPE_SESSION, 0, 0); if (rv != OCI_SUCCESS) oci8_env_raise(oci8_envhp, rv); copy_session_handle(svcctx); /* alocalte a server handle */ rv = OCIHandleAlloc(oci8_envhp, (void*)&svcctx->srvhp, OCI_HTYPE_SERVER, 0, 0); if (rv != OCI_SUCCESS) oci8_env_raise(oci8_envhp, rv); copy_server_handle(svcctx); return self; }
int main(int argc, char *argv[]) { OCIError *errhp = NULL; printf("stage4: Demonstrating OCI statement caching \n"); /* parse command line options */ parse_options(argc, argv); checkenv(envhp, OCIEnvCreate(&envhp, /* returned env handle */ OCI_THREADED, /* initialization modes */ NULL, NULL, NULL, NULL, /* callbacks, context */ (size_t) 0, /* extra memory size: optional */ (void **) NULL)); /* returned extra memory */ /* allocate error handle * note: for OCIHandleAlloc(), we always check error on environment handle */ checkenv(envhp, OCIHandleAlloc(envhp, /* environment handle */ (void **) &errhp, /* returned err handle */ OCI_HTYPE_ERROR,/*type of handle to allocate*/ (size_t) 0, /* extra memory size: optional */ (void **) NULL)); /* returned extra memory */ create_session_pool(envhp, errhp, &poolName, &poolNameLen); /* allocate auth handle * note: for OCIHandleAlloc(), we check error on environment handle */ checkenv(envhp, OCIHandleAlloc(envhp, (void **) &authp, OCI_HTYPE_AUTHINFO, (size_t) 0, (void **) NULL)); /* setup username and password */ checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO, (void *) username, strlen((char *)username), OCI_ATTR_USERNAME, errhp)); checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO, apppassword, strlen((char *) apppassword), OCI_ATTR_PASSWORD, errhp)); spawn_threads(envhp, errhp, &thread_function); /* Destroy the session pool */ OCISessionPoolDestroy(spoolhp, errhp, OCI_DEFAULT); /* clean up */ if (authp) OCIHandleFree(authp, OCI_HTYPE_AUTHINFO); if (spoolhp) OCIHandleFree(spoolhp, OCI_HTYPE_SPOOL); if (errhp) OCIHandleFree(errhp, OCI_HTYPE_ERROR); if (envhp) OCIHandleFree(envhp, OCI_HTYPE_ENV); return 0; }
ocisession::ocisession(const char * connect_str, const int connect_str_len, const char * user_name, const int user_name_len, const char * password, const int password_len) { intf_ret r; OCIAuthInfo *authp = NULL; init(); r.handle = envhp; // allocate error handle checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp, /* environment handle */ (void **) &_errhp, /* returned err handle */ OCI_HTYPE_ERROR, /* typ of handle to allocate */ (size_t) 0, /* optional extra memory size */ (void **) NULL)); /* returned extra memeory */ if(r.fn_ret != SUCCESS) { REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf); throw r; } // allocate auth handle checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp, (void**)&authp, OCI_HTYPE_AUTHINFO, (size_t)0, (void **) NULL)); r.handle = _errhp; // usrname and password checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO, (void*) user_name, user_name_len, OCI_ATTR_USERNAME, (OCIError *)_errhp)); checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO, (void*) password, password_len, OCI_ATTR_PASSWORD, (OCIError *)_errhp)); /* get the database connection */ checkerr(&r, OCISessionGet((OCIEnv*)envhp, (OCIError *)_errhp, (OCISvcCtx**)&_svchp, /* returned database connection */ authp, /* initialized authentication handle */ (OraText *) connect_str, connect_str_len,/* connect string */ NULL, 0, NULL, NULL, NULL, /* session tagging parameters: optional */ OCI_SESSGET_STMTCACHE)); /* modes */ if(r.fn_ret != SUCCESS) { REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf); throw r; } (void) OCIHandleFree(authp, OCI_HTYPE_AUTHINFO); REMOTE_LOG("got session %p\n", _svchp); _sessions.push_back(this); }
void InitHandles() { if (OCIEnvCreate(&henv, OCI_DEFAULT, NULL, NULL, NULL, NULL, 0, NULL) || OCIHandleAlloc(henv, (dvoid*)&hser, OCI_HTYPE_SERVER, 0, NULL) || OCIHandleAlloc(henv, (dvoid*)&herr, OCI_HTYPE_ERROR, 0, NULL) || OCIHandleAlloc(henv, (dvoid*)&husr, OCI_HTYPE_SESSION, 0, NULL) || OCIHandleAlloc(henv, (dvoid*)&hsvc, OCI_HTYPE_SVCCTX, 0, NULL) || OCIHandleAlloc(henv, (dvoid*)&hsql, OCI_HTYPE_STMT, 0, NULL)) { Log("initialize handles failed"); exit(2); } }
/************************************************************************* * * Function: sql_init_socket * * Purpose: Establish connection to the db * *************************************************************************/ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { rlm_sql_oracle_sock *oracle_sock; if (!sqlsocket->conn) { sqlsocket->conn = (rlm_sql_oracle_sock *)rad_malloc(sizeof(rlm_sql_oracle_sock)); if (!sqlsocket->conn) { return -1; } } memset(sqlsocket->conn,0,sizeof(rlm_sql_oracle_sock)); oracle_sock = sqlsocket->conn; if (OCIEnvCreate(&oracle_sock->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0, (dvoid * (*)(dvoid *, size_t)) 0, (dvoid * (*)(dvoid *, dvoid *, size_t))0, (void (*)(dvoid *, dvoid *)) 0, 0, (dvoid **)0 )) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle OCI environment (OCIEnvCreate())"); return -1; } if (OCIHandleAlloc((dvoid *) oracle_sock->env, (dvoid **) &oracle_sock->errHandle, (ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0)) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle ERROR handle (OCIHandleAlloc())"); return -1; } /* Allocate handles for select and update queries */ if (OCIHandleAlloc((dvoid *)oracle_sock->env, (dvoid **) &oracle_sock->queryHandle, (ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0)) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s", sql_error(sqlsocket, config)); return -1; } if (OCILogon(oracle_sock->env, oracle_sock->errHandle, &oracle_sock->conn, config->sql_login, strlen(config->sql_login), config->sql_password, strlen(config->sql_password), config->sql_db, strlen(config->sql_db))) { radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(sqlsocket, config)); sql_close(sqlsocket,config); return -1; } return 0; }
sword ConnectToDb(const char* const uid, const char* const pwd) { sword orc; /* allocate Server and Authentication (Session) handles */ orc = OCIHandleAlloc((dvoid *) envhp, (dvoid **) &srvhp, (ub4) OCI_HTYPE_SERVER, (size_t) 0, (dvoid **) 0); orc = OCIHandleAlloc((dvoid *) envhp, (dvoid **) &authp, (ub4) OCI_HTYPE_SESSION, (size_t) 0, (dvoid **) 0); /* attach to the server */ orc = OCIServerAttach(srvhp, errhp, (text *) 0, 0, (ub4) OCI_DEFAULT); orc = OCIAttrSet((dvoid *) authp, (ub4) OCI_HTYPE_SESSION, (dvoid *) uid, (ub4) strlen((char *)uid), (ub4) OCI_ATTR_USERNAME, errhp); orc = OCIAttrSet((dvoid *) authp, (ub4) OCI_HTYPE_SESSION, (dvoid *) pwd, (ub4) strlen((char *)pwd), (ub4) OCI_ATTR_PASSWORD, errhp); /* set the server attribute in the service context */ orc = OCIAttrSet((dvoid *) svchp, (ub4) OCI_HTYPE_SVCCTX, (dvoid *) srvhp, (ub4) 0, (ub4) OCI_ATTR_SERVER, errhp); /* log on */ orc = OCISessionBegin(svchp, errhp, authp, (ub4) OCI_CRED_RDBMS, (ub4) OCI_DEFAULT); CheckErr(errhp, orc); /* set the session attribute in the service context */ orc = OCIAttrSet((dvoid *) svchp, (ub4) OCI_HTYPE_SVCCTX, (dvoid *) authp, (ub4) 0, (ub4) OCI_ATTR_SESSION, errhp); return (orc); } /* ConnectToDb */
int dbd_oracle_statement_create(lua_State *L, connection_t *conn, const char *sql_query) { int rc; statement_t *statement = NULL; OCIStmt *stmt; char *new_sql; /* * convert SQL string into a Oracle API compatible SQL statement */ new_sql = replace_placeholders(L, ':', sql_query); rc = OCIHandleAlloc((dvoid *)conn->oracle, (dvoid **)&stmt, OCI_HTYPE_STMT, 0, (dvoid **)0); rc = OCIStmtPrepare(stmt, conn->err, new_sql, strlen(new_sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT); free(new_sql); statement = (statement_t *)lua_newuserdata(L, sizeof(statement_t)); statement->conn = conn; statement->stmt = stmt; statement->num_columns = 0; statement->bind = NULL; statement->metadata = 0; luaL_getmetatable(L, DBD_ORACLE_STATEMENT); lua_setmetatable(L, -2); return 1; }
/* * call-seq: * OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, username = nil, password = nil, dbname = nil) -> connection pool * OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, connect_string) -> connection pool * * Creates a connection pool. * * <i>conn_min</i> specifies the minimum number of connections in the * connection pool. Valid values are 0 and higher. * * <i>conn_max</i> specifies the maximum number of connections that * can be opened to the database. Once this value is reached, no more * connections are opened. Valid values are 1 and higher. * * <i>conn_incr</i> allows the application to set the next increment * for connections to be opened to the database if the current number * of connections are less than <i>conn_max</i>. Valid values are 0 * and higher. * * <i>username</i> and <i>password</i> are required to establish an * implicit primary session. When both are nil, external * authentication is used. * * <i>dbname</i> specifies the database server to connect to. * * If the number of arguments is four, <i>username</i>, * <i>password</i> and <i>dbname</i> are extracted from the fourth * argument <i>connect_string</i>. The syntax is "username/password" or * "username/password@dbname". */ static VALUE oci8_cpool_initialize(int argc, VALUE *argv, VALUE self) { VALUE conn_min; VALUE conn_max; VALUE conn_incr; VALUE username; VALUE password; VALUE dbname; oci8_cpool_t *cpool = DATA_PTR(self); OraText *pool_name; sb4 pool_name_len; sword rv; /* check arguments */ rb_scan_args(argc, argv, "42", &conn_min, &conn_max, &conn_incr, &username, &password, &dbname); Check_Type(conn_min, T_FIXNUM); Check_Type(conn_max, T_FIXNUM); Check_Type(conn_incr, T_FIXNUM); if (argc == 4) { VALUE mode; VALUE conn_str = username; OCI8SafeStringValue(conn_str); oci8_do_parse_connect_string(conn_str, &username, &password, &dbname, &mode); if (!NIL_P(mode)) { rb_raise(rb_eArgError, "invalid connect string \"%s\": Connection pooling doesn't support sysdba and sysoper privileges.", RSTRING_PTR(conn_str)); } } else { if (!NIL_P(username)) { OCI8SafeStringValue(username); } if (!NIL_P(password)) { OCI8SafeStringValue(password); } if (!NIL_P(dbname)) { OCI8SafeStringValue(dbname); } } rv = OCIHandleAlloc(oci8_envhp, &cpool->base.hp.ptr, OCI_HTYPE_CPOOL, 0, NULL); if (rv != OCI_SUCCESS) oci8_env_raise(oci8_envhp, rv); cpool->base.type = OCI_HTYPE_CPOOL; oci_lc(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp, &pool_name, &pool_name_len, NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname), NIL_P(dbname) ? 0 : RSTRING_LEN(dbname), FIX2UINT(conn_min), FIX2UINT(conn_max), FIX2UINT(conn_incr), NIL_P(username) ? NULL : RSTRING_ORATEXT(username), NIL_P(username) ? 0 : RSTRING_LEN(username), NIL_P(password) ? NULL : RSTRING_ORATEXT(password), NIL_P(password) ? 0 : RSTRING_LEN(password), OCI_DEFAULT)); cpool->pool_name = rb_str_new(TO_CHARPTR(pool_name), pool_name_len); rb_str_freeze(cpool->pool_name); return Qnil; }
void Statement::Prepare(std::string const& sqlBlock) { ASSERT(m_conn != NULL && sqlBlock.empty() != true); ASSERT(m_stmtHandle == NULL); sword result; result = OCIHandleAlloc(m_conn->m_environmentHandle , (void **) &m_stmtHandle,OCI_HTYPE_STMT, 0, NULL); if(result == OCI_SUCCESS) { result = OCIStmtPrepare(m_stmtHandle, m_conn->m_errorHandle , (text*) sqlBlock.c_str(), sqlBlock.size(), OCI_NTV_SYNTAX, OCI_DEFAULT); } else { throw Error (result, m_conn->m_environmentHandle, __FILE__, __LINE__); } if(result == OCI_SUCCESS) { ub2 stmtType = 0; result = OCIAttrGet (m_stmtHandle, OCI_HTYPE_STMT , &stmtType, NULL, OCI_ATTR_STMT_TYPE, m_conn->m_errorHandle); m_type = (StatementType)stmtType; } if( result == OCI_SUCCESS) { m_isPrepared = true; m_isExecuted = false; } else { throw Error (result, m_conn->m_errorHandle, __FILE__, __LINE__); } }
static int db_getn(int type, int keytype) { int n = 0; char table[20]; char *sql = "select count(*) as n from %s where type=%d"; OraText row[4000]; OCIDefine *dnp = NULL; strcpy(table, (type == TYPE_KILL)? "kill_key" : "monitor_key"); sprintf((char*)row, sql,table, keytype); checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), myerrhp); checkerr(OCIStmtPrepare(mystmthp, myerrhp, row, (ub4)strlen((char*)row), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT), myerrhp); checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, (ub4)0, (ub4)0, (CONST OCISnapshot *)0, (OCISnapshot *)0, OCI_DEFAULT), myerrhp); if ((status = OCIDefineByPos(mystmthp, &dnp, myerrhp, 1, &n, sizeof(n), SQLT_INT, (dvoid *)0, 0, (ub2 *)0, OCI_DEFAULT))) { checkerr(status, myerrhp); return -1; } if(OCIStmtFetch2(mystmthp, myerrhp, 1, OCI_FETCH_NEXT, 0, OCI_DEFAULT) != OCI_NO_DATA) { return n; } return 0; }
static int o_init (void) /* {{{ */ { int status; if (oci_env != NULL) return (0); status = OCIEnvCreate (&oci_env, /* mode = */ OCI_THREADED, /* context = */ NULL, /* malloc = */ NULL, /* realloc = */ NULL, /* free = */ NULL, /* user_data_size = */ 0, /* user_data_ptr = */ NULL); if (status != 0) { ERROR ("oracle plugin: OCIEnvCreate failed with status %i.", status); return (-1); } status = OCIHandleAlloc (oci_env, (void *) &oci_error, OCI_HTYPE_ERROR, /* user_data_size = */ 0, /* user_data = */ NULL); if (status != OCI_SUCCESS) { ERROR ("oracle plugin: OCIHandleAlloc (OCI_HTYPE_ERROR) failed " "with status %i.", status); return (-1); } return (0); } /* }}} int o_init */
int CheckLobType() { OCIStmt *stmtlobtypehp; OCIDefine *defv1 = 0; char LobType[4]; static text *stmt_lobtype = (text *)"SELECT securefile from user_lobs where table_name='FOO' and column_name='DOCUMENT' "; LobType[3]='\0'; CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmtlobtypehp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0)); CheckErr(errhp, OCIStmtPrepare(stmtlobtypehp, errhp, (CONST text *) stmt_lobtype, strlen((char *) stmt_lobtype), OCI_NTV_SYNTAX, OCI_DEFAULT)); CheckErr(errhp, OCIDefineByPos (stmtlobtypehp, (OCIDefine **) &defv1, errhp, 1, &LobType, 4, SQLT_STR, (dvoid *)0, (ub2 *)0, (ub2 *)0, OCI_DEFAULT)); CheckErr(errhp, OCIStmtExecute(svchp, stmtlobtypehp, errhp, (ub4) 1, (ub4) 0, (CONST OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT)); if ( (strcmp(LobType, "YES")) == 0 ) return (1) ; else return (0) ; }
ResultSet_T OracleConnection_executeQuery(T C, const char *sql, va_list ap) { OCIStmt* stmtp; va_list ap_copy; assert(C); C->rowsChanged = 0; va_copy(ap_copy, ap); StringBuffer_vset(C->sb, sql, ap_copy); va_end(ap_copy); StringBuffer_trim(C->sb); /* Build statement */ C->lastError = OCIHandleAlloc(C->env, (void **)&stmtp, OCI_HTYPE_STMT, 0, NULL); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) return NULL; C->lastError = OCIStmtPrepare(stmtp, C->err, StringBuffer_toString(C->sb), StringBuffer_length(C->sb), OCI_NTV_SYNTAX, OCI_DEFAULT); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) { OCIHandleFree(stmtp, OCI_HTYPE_STMT); return NULL; } /* Execute and create Result Set */ C->lastError = OCIStmtExecute(C->svc, stmtp, C->err, 0, 0, NULL, NULL, OCI_DEFAULT); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) { ub4 parmcnt = 0; OCIAttrGet(stmtp, OCI_HTYPE_STMT, &parmcnt, NULL, OCI_ATTR_PARSE_ERROR_OFFSET, C->err); DEBUG("Error occured in StmtExecute %d (%s), offset is %d\n", C->lastError, OracleConnection_getLastError(C), parmcnt); OCIHandleFree(stmtp, OCI_HTYPE_STMT); return NULL; } C->lastError = OCIAttrGet(stmtp, OCI_HTYPE_STMT, &C->rowsChanged, 0, OCI_ATTR_ROW_COUNT, C->err); if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) DEBUG("OracleConnection_execute: Error in OCIAttrGet %d (%s)\n", C->lastError, OracleConnection_getLastError(C)); return ResultSet_new(OracleResultSet_new(stmtp, C->env, C->usr, C->err, C->svc, true, C->maxRows), (Rop_T)&oraclerops); }
/* ** Execute an SQL statement. ** Return a Cursor object if the statement is a query, otherwise ** return the number of tuples affected by the statement. */ static int conn_execute (lua_State *L) { env_data *env; conn_data *conn = getconnection (L); const char *statement = luaL_checkstring (L, 2); sword status; ub4 prefetch = 0; ub4 iters; ub4 mode; ub2 type; OCIStmt *stmthp; /* get environment */ lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env); if (!lua_isuserdata (L, -1)) luaL_error(L,LUASQL_PREFIX"invalid environment in connection!"); env = (env_data *)lua_touserdata (L, -1); /* statement handle */ ASSERT (L, OCIHandleAlloc ((dvoid *)env->envhp, (dvoid **)&stmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), conn->errhp); ASSERT (L, OCIAttrSet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT, (dvoid *)&prefetch, (ub4)0, (ub4)OCI_ATTR_PREFETCH_ROWS, conn->errhp), conn->errhp); ASSERT (L, OCIStmtPrepare (stmthp, conn->errhp, (text *)statement, (ub4) strlen(statement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT), conn->errhp); /* statement type */ ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4) OCI_HTYPE_STMT, (dvoid *)&type, (ub4 *)0, (ub4)OCI_ATTR_STMT_TYPE, conn->errhp), conn->errhp); if (type == OCI_STMT_SELECT) iters = 0; else iters = 1; if (conn->auto_commit) mode = OCI_COMMIT_ON_SUCCESS; else mode = OCI_DEFAULT; /* execute statement */ status = OCIStmtExecute (conn->svchp, stmthp, conn->errhp, iters, (ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, mode); if (status && (status != OCI_NO_DATA)) { OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT); return checkerr (L, status, conn->errhp); } if (type == OCI_STMT_SELECT) { /* create cursor */ return create_cursor (L, 1, conn, stmthp, statement); } else { /* return number of rows */ int rows_affected; ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT, (dvoid *)&rows_affected, (ub4 *)0, (ub4)OCI_ATTR_ROW_COUNT, conn->errhp), conn->errhp); OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT); lua_pushnumber (L, rows_affected); return 1; } }
OWStatement::OWStatement( OWConnection* pConnect, const char* pszStatement ) { poConnection = pConnect; nStmtMode = OCI_DEFAULT; nNextCol = 0; nNextBnd = 0; hError = poConnection->hError; // ----------------------------------------------------------- // Create Statement handler // ----------------------------------------------------------- OCIStmt* hStatement; CheckError( OCIHandleAlloc( (dvoid*) poConnection->hEnv, (dvoid**) (dvoid*) &hStatement, (ub4) OCI_HTYPE_STMT, (size_t) 0, (dvoid**) NULL), hError ); hStmt = hStatement; // Save Statement Handle // ----------------------------------------------------------- // Prepare Statement // ----------------------------------------------------------- CheckError( OCIStmtPrepare( hStmt, hError, (text*) pszStatement, (ub4) strlen(pszStatement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT ), hError ); // ----------------------------------------------------------- // Get Statement type // ----------------------------------------------------------- ub2 nStmtType; CheckError( OCIAttrGet( (dvoid*) hStmt, (ub4) OCI_HTYPE_STMT, (dvoid*) &nStmtType, (ub4*) 0, (ub4) OCI_ATTR_STMT_TYPE, hError ), hError ); // ----------------------------------------------------------- // Set Statement mode // ----------------------------------------------------------- if( nStmtType != OCI_STMT_SELECT ) { nStmtMode = OCI_DEFAULT; } CPLDebug("PL/SQL","\n%s\n", pszStatement); }
DpiHandle * EnvImpl::allocHandle(HandleType handleType) { void *handle = NULL; ociCallEnv(OCIHandleAlloc(envh_, &handle, handleType, 0, NULL), envh_); return (DpiHandle *)handle; }
/************************************************************************* * * Function: sql_socket_init * * Purpose: Establish connection to the db * *************************************************************************/ static int sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config) { rlm_sql_oracle_conn_t *conn; MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_oracle_conn_t)); talloc_set_destructor((void *) conn, sql_socket_destructor); if (OCIEnvCreate(&conn->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0, (dvoid * (*)(dvoid *, size_t)) 0, (dvoid * (*)(dvoid *, dvoid *, size_t))0, (void (*)(dvoid *, dvoid *)) 0, 0, (dvoid **)0 )) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle OCI environment (OCIEnvCreate())"); return -1; } if (OCIHandleAlloc((dvoid *) conn->env, (dvoid **) &conn->errHandle, (ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0)) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle ERROR handle (OCIHandleAlloc())"); return -1; } /* Allocate handles for select and update queries */ if (OCIHandleAlloc((dvoid *)conn->env, (dvoid **) &conn->queryHandle, (ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0)) { radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s", sql_error(handle, config)); return -1; } if (OCILogon(conn->env, conn->errHandle, &conn->ctx, config->sql_login, strlen(config->sql_login), config->sql_password, strlen(config->sql_password), config->sql_db, strlen(config->sql_db))) { radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(handle, config)); return -1; } return 0; }
connection(asio::io_service& io_service) : sql::detail::connection_base<detail::service>(io_service) { if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&server), OCI_HTYPE_SERVER, 0, 0)) throw std::bad_alloc(); if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&error), OCI_HTYPE_ERROR, 0, 0)) throw std::bad_alloc(); if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&svcctx), OCI_HTYPE_SVCCTX, 0, 0)) throw std::bad_alloc(); if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&session), OCI_HTYPE_SESSION, 0, 0)) throw std::bad_alloc(); }
int db_insert(mail_t *mail, char *keyword, int type, unsigned short port) { OraText Insertp[SQL_MAXLINE]; OCIBind *bind1 = NULL; OCIBind *bind2 = NULL; char table[20]; char keywordselect[100]; char *sql = "insert into %s values(id_seq.nextval,sysdate,'%s','%s','%s','%s', :1,'%s', :2,%d)"; assert(mail); assert(keyword); if (type == TYPE_KILL) { strcpy(table, "kill_log"); } else if (type == TYPE_MONITOR) { strcpy(table, "monitor_log"); } else { strcpy(table, "spam_log"); } strcpy(keywordselect, keyword); pretreatment(mail, keywordselect); /* 插入 */ sprintf((char*)Insertp, sql, table, keywordselect, mail->from, mail->to, mail->subject, mail->attach_name, port); DEBUG("In Progressing:%s\n",Insertp); checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), myerrhp); checkerr(OCIStmtPrepare(mystmthp, myerrhp, Insertp, (ub4)strlen((char*)Insertp), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT), myerrhp); DEBUG("content: %s\n attach_content: %s\n", mail->content, mail->attach_content); checkerr(OCIBindByPos(mystmthp, &bind1, myerrhp, 1, mail->content, strlen(mail->content) + 1, SQLT_STR, NULL, NULL, NULL, 0, NULL, OCI_DEFAULT), myerrhp); checkerr(OCIBindByPos(mystmthp, &bind2, myerrhp, 2, mail->attach_content, strlen(mail->attach_content) + 1, SQLT_STR, NULL, NULL, NULL, 0, NULL, OCI_DEFAULT), myerrhp); checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, (ub4)1, (ub4)0, (CONST OCISnapshot *)0, (OCISnapshot *)0, OCI_DEFAULT), myerrhp); checkerr(OCITransCommit(mysvchp, myerrhp, (ub4)0), myerrhp); assert(mail->content); assert(mail->attach_content); if (strcmp(mail->content, "") == 0) { mail->content = NULL; } if (strcmp(mail->attach_content, "") == 0) { mail->attach_content = NULL; } return 0; }
/* Function to get an array of REFs to populate the varray of REFs*/ static void getRef() { OCIDefine *defhp = (OCIDefine *) 0; /* For the REF column */ i_residence *sub_obj[NUMREC]; ub4 subsize[NUMREC]; ub4 pos = 0; ub4 arraySize = NUMREC; OCIHandleAlloc(envhp, (dvoid **) &stmthp, OCI_HTYPE_STMT, (size_t) 0, ((dvoid **) 0)); if((status = OCIStmtPrepare(stmthp, errhp, (text *) selRef, (ub4) strlen((char *) selRef), OCI_NTV_SYNTAX, OCI_DEFAULT)) != OCI_SUCCESS) { printf("OciStmtPrepare - Failure\n"); } if((status = OCIObjectNew(envhp, errhp, svchp, OCI_TYPECODE_REF, (OCIType *) 0, (dvoid *) 0, OCI_DURATION_DEFAULT, FALSE, (dvoid **) workadd)) != OCI_SUCCESS) { printf("OCIObjectNew - Failure\n"); } if((status = OCIDefineByPos(stmthp, &defhp, errhp, (ub4) 1, (dvoid *) 0, (sb4) 0, SQLT_REF, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) OCI_DEFAULT )) != OCI_SUCCESS) { printf("OCIDefineByPos - Failure\n"); } if((status = OCIDefineObject(defhp, errhp, (OCIType *) 0, (dvoid **) workadd, subsize, (dvoid **) 0, (ub4 *) 0)) != OCI_SUCCESS) { printf("OCIDefineObject - failure\n"); } if((status = OCIStmtExecute(svchp, stmthp, errhp, (ub4) NUMREC, (ub4) 0, (OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT)) != OCI_SUCCESS) { printf("OCIStmtExecute - Failure\n"); } else { if((status = OCIObjectArrayPin(envhp, errhp, workadd, (ub4) arraySize, (OCIComplexObject **) 0, 0, OCI_PIN_ANY, OCI_DURATION_SESSION, OCI_LOCK_NONE, (dvoid **) sub_obj, (ub4 *) &pos)) != OCI_SUCCESS) { printf("OCIObjectArrayPin - Failure\n"); } } OCIHandleFree((dvoid *) stmthp, OCI_HTYPE_STMT); } /* End of getRef() */
/* Allocate the environment structure for use by the SQL routines. */ int cllOpenEnv( icatSessionStruct *icss ) { int stat; OCIEnv *p_env; OCISvcCtx *p_svc; stat = OCIEnvCreate( ( OCIEnv ** )&p_env, ( ub4 )OCI_DEFAULT, ( dvoid * )0, ( dvoid * ( * )( dvoid *, size_t ) )0, ( dvoid * ( * )( dvoid *, dvoid *, size_t ) )0, ( void ( * )( dvoid *, dvoid * ) )0, ( size_t )0, ( dvoid ** )0 ); if ( stat != OCI_SUCCESS ) { rodsLog( LOG_ERROR, "cllOpenEnv: OCIEnvCreate failed" ); return CAT_ENV_ERR; } /* Initialize handles */ stat = OCIHandleAlloc( ( dvoid * ) p_env, ( dvoid ** ) &p_err, OCI_HTYPE_ERROR, ( size_t ) 0, ( dvoid ** ) 0 ); if ( stat != OCI_SUCCESS ) { rodsLog( LOG_ERROR, "cllOpenEnv: OCIHandleAlloc failed" ); return CAT_ENV_ERR; } stat = OCIHandleAlloc( ( dvoid * ) p_env, ( dvoid ** ) &p_svc, OCI_HTYPE_SVCCTX, ( size_t ) 0, ( dvoid ** ) 0 ); if ( stat != OCI_SUCCESS ) { rodsLog( LOG_ERROR, "cllOpenEnv: OCIHandleAlloc failed" ); return CAT_ENV_ERR; } icss->connectPtr = p_svc; icss->environPtr = p_env; return 0; }
int OracleConnection_beginTransaction(T C) { assert(C); if (C->txnhp == NULL) /* Allocate handler only once, if it is necessary */ { /* allocate transaction handle and set it in the service handle */ C->lastError = OCIHandleAlloc(C->env, (void **)&C->txnhp, OCI_HTYPE_TRANS, 0, 0); if (C->lastError != OCI_SUCCESS) return false; OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, (void *)C->txnhp, 0, OCI_ATTR_TRANS, C->err); } C->lastError = OCITransStart (C->svc, C->err, ORACLE_TRANSACTION_PERIOD, OCI_TRANS_NEW); return (C->lastError == OCI_SUCCESS); }
int db_init(char *servername, char *username, char *passwd) { OCIEnvCreate(&myenvhp, OCI_THREADED|OCI_OBJECT, (dvoid *)0, 0, 0, 0, (size_t)0, (dvoid **)0); OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mysrvhp, OCI_HTYPE_SERVER, 0, (dvoid **)0); OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&myerrhp, OCI_HTYPE_ERROR, 0, (dvoid **)0); /* 服务名 */ status = OCIServerAttach(mysrvhp, myerrhp, (const OraText*)servername, strlen(servername), OCI_DEFAULT); if (status != OCI_SUCCESS && status != OCI_SUCCESS_WITH_INFO) { checkerr(status, myerrhp); OCIServerDetach(mysrvhp, myerrhp, OCI_DEFAULT); return -1; } OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mysvchp, OCI_HTYPE_SVCCTX, 0, (dvoid **)0); OCIAttrSet((dvoid *)mysvchp, OCI_HTYPE_SVCCTX, (dvoid *)mysrvhp, (ub4)0, OCI_ATTR_SERVER, myerrhp); OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&myusrhp, OCI_HTYPE_SESSION, 0, (dvoid **)0); OCIAttrSet((dvoid *)myusrhp, OCI_HTYPE_SESSION, (dvoid *)username, (ub4)strlen(username), OCI_ATTR_USERNAME, myerrhp); OCIAttrSet((dvoid *)myusrhp, OCI_HTYPE_SESSION, (dvoid *)passwd, (ub4)strlen(passwd), OCI_ATTR_PASSWORD, myerrhp); if(OCISessionBegin((dvoid *)mysvchp, myerrhp, myusrhp, OCI_CRED_RDBMS, OCI_DEFAULT) != OCI_SUCCESS) { DEBUG("Build the talking fail!\n"); OCIHandleFree((void *)myenvhp, OCI_HTYPE_ENV); return -1; } OCIAttrSet((dvoid *)mysvchp, OCI_HTYPE_SVCCTX, (dvoid *)myusrhp, (ub4)0, OCI_ATTR_SESSION, myerrhp); INFO("Oracle connect successful!\n"); return 0; }
/** * test that blacktie correctly drives oracle xa * Precondition: - there is an active transaction (implies that that there is open XA connection) * * arguments: * op - 0 for insert 1 for select 2 for update and 3 for delete (CRUD) * arg - used in selects to hold the expected number of records * rbuf - used to report error strings (except in a successful select it holds the number of matching records) * bufsz - the length of rbuf */ int ora_access(test_req_t *req, test_req_t *resp) { OCIStmt *stmthp; OCIError *errhp; OCIEnv *xaEnv; OCISvcCtx *svcCtx; sword status; btlogger_debug( "TxLog ora_access op=%c data=%s db=%s", req->op, req->data, req->db); /* opening an XA connection creates an environment and service context */ xaEnv = (struct OCIEnv *) xaoEnv((text *) req->db) ; svcCtx = (struct OCISvcCtx *) xaoSvcCtx((text *) req->db); btlogger("TxLog ora_access env=%p svc=%p\n", xaEnv, svcCtx); if (xaEnv == NULL) return fatal("TxLog ORA:- Unable to obtain env!"); if (svcCtx == NULL) return fatal("TxLog ORA:- Unable to obtain service context!"); /* initialise OCI handles */ if (OCI_SUCCESS != OCIHandleAlloc((dvoid *)xaEnv, (dvoid **)&errhp, OCI_HTYPE_ERROR, 0, (dvoid **)0)) return fatal("ORA:- Unable to allocate statement handle"); if (OCI_SUCCESS != OCIHandleAlloc((dvoid *)xaEnv, (dvoid **)&stmthp, OCI_HTYPE_STMT, 0, (dvoid **)0)) return fatal("ORA:- Unable to allocate error handle"); /* run the test */ status = doWork(req->op, req->data, svcCtx, stmthp, errhp, resp); btlogger_debug( "TxLog %d: doWork %c returned: %s", status, req->op, resp->data); // return status; // OCI_SUCCESS is 0 return (status != OCI_SUCCESS); // 0 means success }
void TurnOnSqlTrace() { OCIStmt *stmttracehp; static text *stmt_traceon = (text *)"alter session set events '10046 trace name context forever, level 8'"; CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmttracehp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0)); CheckErr(errhp, OCIStmtPrepare(stmttracehp, errhp, (CONST text *) stmt_traceon, strlen((char *) stmt_traceon), OCI_NTV_SYNTAX, OCI_DEFAULT)); CheckErr(errhp, OCIStmtExecute(svchp, stmttracehp, errhp, (ub4) 1, (ub4) 0, (CONST OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT)); }
char* db_select(int type, int keytype, int *num) { int i; text dkeyword[SQL_MAXCOLUMN]; ub4 col_keyword_len=0; char *words; OraText sentence[SQL_MAXLINE]; char table[20]; char *sql = "select keyword from %s where type=%d"; *num = db_getn(type, keytype); if (*num == -1 || *num == 0) { return NULL; } strcpy(table, (type == TYPE_KILL )? "kill_key" : "monitor_key"); sprintf((char*)sentence, sql, table, keytype); checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp, OCI_HTYPE_STMT, 0, 0), myerrhp); checkerr(OCIStmtPrepare(mystmthp, myerrhp, sentence, strlen((char*)sentence), OCI_NTV_SYNTAX, OCI_DEFAULT), myerrhp); checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, 0, 0, 0, 0, OCI_DEFAULT), myerrhp); if (OCIParamGet(mystmthp, OCI_HTYPE_STMT, myerrhp, (void **)&mypardp, 1) != OCI_SUCCESS) { return NULL; } checkerr(OCIAttrGet((dvoid*)mypardp, OCI_DTYPE_PARAM, (dvoid*)&col_keyword_len, 0, OCI_ATTR_DATA_SIZE, myerrhp), myerrhp); if ((status = OCIDefineByPos(mystmthp, &defkeywordp, myerrhp, 1, dkeyword, col_keyword_len + 1, SQLT_STR, 0, 0, 0, OCI_DEFAULT))) { checkerr(status, myerrhp); return NULL; } if (!CALLOC(words, *num, SQL_MAXCOLUMN)) { return NULL; } for(i = 0; i < *num; i++) { checkerr(OCIStmtFetch2(mystmthp, myerrhp, 1, OCI_FETCH_NEXT, i, OCI_DEFAULT), myerrhp); strcpy(words + SQL_MAXCOLUMN*i, (char*)dkeyword); } return words; }
void OD_Create_cursor(sLONG_PTR *pResult, PackagePtr pParams) { C_LONGINT Param1; C_LONGINT returnValue; Param1.fromParamAtIndex(pParams, 1); uint32_t sessionId = Param1.getIntValue(); sessionInfo *session = _sessionGet(sessionId); if(session) { unsigned int i = 0; OCIStmt *stmtp = 0; OCIError *errhp = 0; OCIEnv *envhp = session->envhp; OCIHandleAlloc((dvoid *)envhp, (dvoid **)&stmtp, OCI_HTYPE_STMT, 0, 0); OCIHandleAlloc((dvoid *)envhp, (dvoid **)&errhp, OCI_HTYPE_ERROR, 0, 0); _cursorCreate(&i, sessionId, stmtp, errhp); returnValue.setIntValue(i); if(!i) { OCIHandleFree(stmtp, OCI_HTYPE_STMT); OCIHandleFree(errhp, OCI_HTYPE_ERROR); returnValue.setIntValue(-1); } } returnValue.setReturn(pResult); }