int FC_FUNC_(oraclesim_getnet, ORACLESIM_GETNET)
(OracleDbConnection **fdbconnid, const char *netdesc) {
OracleDbConnection *dbconnid = *fdbconnid;
sword status;
int onetid;
/* Preparo l'estrazione per ottenere il numero della rete dal nome */
checkerr(dbconnid,
OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) netquery,
(ub4) strlen(netquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":netdesc",
-1, (dvoid *) netdesc,
(sword) strlen(netdesc)+1, SQLT_STR, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid,
OCIDefineByPos(dbconnid->stmthp, &dbconnid->defn1p,
dbconnid->errhp, 1,
(dvoid *) &onetid, sizeof(onetid), SQLT_INT,
(dvoid *) 0,
(ub2 *) 0, (ub2 *) 0, OCI_DEFAULT));
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Prendo la prima riga di dati */
if ((status = OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_NEXT, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status == OCI_NO_DATA) {
return 0;
} else {
checkerr(dbconnid, status);
return -1;
}
}
return onetid;
}
int COracleDB::oracle_exec( const char* sql, bool commit )
{
if ( _handle == NULL )
return DB_ERR_NOCONNECTION;
if ( sql == NULL )
return DB_ERR_PARAMERROR;
int status = 0;
int errcode = DB_ERR_SUCCESS;
ORACLE_HANDLE* handle = ( ORACLE_HANDLE* ) _handle;
status = OCIStmtPrepare( handle->stmthp, handle->errhp, ( text * ) sql, ( ub4 ) strlen( sql ),
( ub4 ) OCI_NTV_SYNTAX, ( ub4 ) OCI_DEFAULT );
if ( status == OCI_STILL_EXECUTING ) {
my_usleep();
}
time_t t1 = time( NULL );
status = OCIStmtExecute( handle->svchp, handle->stmthp, handle->errhp, 1, 0, NULL, NULL, OCI_DEFAULT );
if ( status == OCI_STILL_EXECUTING ) {
my_usleep();
}
if ( time( NULL ) - t1 > 60 ) {
// timeout
errcode = DB_ERR_TIMEOUT;
}
if ( errcode == DB_ERR_SUCCESS && status != OCI_SUCCESS_WITH_INFO && status != OCI_SUCCESS ) {
errcode = checkerr( handle->errhp, status, _errinfo, sql );
if ( errcode == 1012 || errcode == 12705 || errcode == 3113 || errcode == 3114 || errcode == 12541
|| errcode == 12547 ) {
errcode = DB_ERR_NOCONNECTION;
} else {
errcode = DB_ERR_FAILED;
}
}
if ( commit )
oracle_commit();
// printf("%s ret: %d \n", sql, errcode);
return errcode;
}
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));
}
/* select test */
static int doSelect(OCISvcCtx *svcCtx, OCIStmt *stmthp, OCIError *errhp, int empno, int *rcnt) {
OCIBind *bndp = (OCIBind *) 0;
text *sql = (text *) "SELECT ENAME,JOB FROM EMP WHERE EMPNO >= :1" ;
char emp[20];
char job[20];
OCIDefine *stmtdef1 = (OCIDefine *) 0;
OCIDefine *stmtdef2 = (OCIDefine *) 0;
sword status = OCIStmtPrepare(stmthp, errhp, (text *) sql, (ub4) strlen((char *) sql), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT);
// THIS IS A C FILE SO DECLARATIONS UP TOP
btlogger_debug( "TxLog doSelect: :1=%d", empno);
/* bind empno to the statement */
if (status == OCI_SUCCESS)
status = OCIBindByPos(stmthp, &bndp, errhp, 1, (dvoid *) &empno, (sword) sizeof (empno),
SQLT_INT, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
/* define the output variables for the select */
if (status == OCI_SUCCESS)
status = OCIDefineByPos(stmthp, &stmtdef1, errhp, 1, (dvoid *)&emp,(sword) sizeof (emp), SQLT_STR,
(dvoid *) 0, (ub2 *)0, (ub2 *)0, (ub4) OCI_DEFAULT);
if (status == OCI_SUCCESS)
status = OCIDefineByPos(stmthp, &stmtdef2, errhp, 2, (dvoid *)&job,(sword) sizeof (job), SQLT_STR,
(dvoid *) 0, (ub2 *)0, (ub2 *)0, (ub4) OCI_DEFAULT);
/* exectute the select */
if (status == OCI_SUCCESS)
status = OCIStmtExecute(svcCtx, stmthp, errhp, (ub4) 0, (ub4) 0, (CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
btlogger_debug( "TxLog executing statement: %s :1=%d", sql, empno);
*rcnt = 0;
if (status != OCI_SUCCESS && status != OCI_NO_DATA) {
show_error(errhp, status);
return status;
} else {
while (1) {
status = OCIStmtFetch(stmthp, errhp, (ub4) 1, (ub4) OCI_FETCH_NEXT, (ub4) OCI_DEFAULT);
if (status != OCI_SUCCESS && status != OCI_SUCCESS_WITH_INFO)
break;
btlogger_debug( "TxLog Name: %s Job: %s", emp, job);
(*rcnt) += 1;
}
btlogger_debug( "TxLog result: %d", *rcnt);
return OCI_SUCCESS;
}
}
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;
}
// "Подготовка" (compile, parsing, preparing) SQL для выполнения по exec...
int ora_compile(database *db, char *sql) {
t_ora *o = db->h;
if (!o) return ora_error(db);
db->err_code = 0; o->execnum = 0; db->in.count = 0; // Все почистили...
if (strncmp(sql,"vovka",5)==0)
{
in_command(sql+5,db->error);
return 0;
}
//OCILobTrim(o->svchp, o->errhp, o->blob,0);
if (!ora_ok(OCIStmtPrepare(o->stmt, o->errhp, (text *) sql,
(ub4) strlen(sql),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT))) return ora_error(db);
return 1;
}
int DataBase::_DB_PrepareSQL(string &sql)
{
tmpParam.size = 0;
memset(strSql, 0 ,sizeof(strSql) );
sprintf(strSql, "%s", sql.c_str() );
if( _DB_CheckErr(OCIStmtPrepare( DBSession->selectp,
DBSession->errhp, (text *)strSql, (ub4)strlen( (char *)strSql ),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT)) < 0 )
{
cout<<"[ "<<__FILE__<<" ] [ "<<__LINE__<<" ] errStr = "<<errStr<<endl;
return DB_FAILURE;
}
return OCI_SUCCESS;
}
void exec_sql_stmt(char *stmt)
{
int ret_val;
// allocate a statement handle
ret_val = OCIHandleAlloc(db_connection2->envhp, (dvoid **)&(db_connection2->stmthp), OCI_HTYPE_STMT, 0, NULL);
// prepare the statement
ret_val = OCIStmtPrepare(db_connection2->stmthp,
db_connection2->errhp,
(unsigned char *)stmt,
strlen(stmt),
OCI_NTV_SYNTAX,
OCI_DEFAULT);
if (ret_val == OCI_ERROR)
{
return;
}
// Execute the statement with 1(NON_SELECT_TYPE) as the fourth parameter
// to tell that it not a select statement.
ret_val = OCIStmtExecute(db_connection2->svchp,
db_connection2->stmthp,
db_connection2->errhp,
1,
0,
NULL,
NULL,
OCI_DEFAULT | OCI_COMMIT_ON_SUCCESS);
if (ret_val == OCI_ERROR)
{
return;
}
// close the statement
ret_val = OCIStmtFetch(db_connection2->stmthp,
db_connection2->errhp,
0,
OCI_FETCH_NEXT,
OCI_DEFAULT);
if (ret_val == OCI_ERROR)
{
return;
}
// Close the statement handle
OCIHandleFree(db_connection2->stmthp, OCI_HTYPE_STMT);
}
static VALUE exec_sql(cb_arg_t *arg)
{
ub4 pos;
sword rv;
rv = OCIHandleAlloc(oci8_envhp, (dvoid*)&arg->stmtp, OCI_HTYPE_STMT, 0, NULL);
if (rv != OCI_SUCCESS) {
oci8_env_raise(oci8_envhp, rv);
}
chker2(OCIStmtPrepare(arg->stmtp, oci8_errhp, (text*)arg->sql_text,
strlen(arg->sql_text), OCI_NTV_SYNTAX, OCI_DEFAULT),
&arg->svcctx->base);
for (pos = 0; pos < arg->num_define_vars; pos++) {
arg->define_vars[pos].hp = NULL;
chker3(OCIDefineByPos(arg->stmtp, (OCIDefine**)&arg->define_vars[pos].hp,
oci8_errhp, pos + 1, arg->define_vars[pos].valuep,
arg->define_vars[pos].value_sz,
arg->define_vars[pos].dty, arg->define_vars[pos].indp,
arg->define_vars[pos].alenp, NULL, OCI_DEFAULT),
&arg->svcctx->base, arg->stmtp);
}
for (pos = 0; pos < arg->num_bind_vars; pos++) {
arg->bind_vars[pos].hp = NULL;
chker3(OCIBindByPos(arg->stmtp, (OCIBind**)&arg->bind_vars[pos].hp,
oci8_errhp, pos + 1, arg->bind_vars[pos].valuep,
arg->bind_vars[pos].value_sz, arg->bind_vars[pos].dty,
arg->bind_vars[pos].indp, arg->bind_vars[pos].alenp,
NULL, 0, NULL, OCI_DEFAULT),
&arg->svcctx->base, arg->stmtp);
}
rv = OCIStmtExecute_nb(arg->svcctx, arg->svcctx->base.hp.svc, arg->stmtp, oci8_errhp, 1, 0, NULL, NULL, OCI_DEFAULT);
if (rv == OCI_ERROR) {
if (oci8_get_error_code(oci8_errhp) == 1000) {
/* run GC to close unreferred cursors
* when ORA-01000 (maximum open cursors exceeded).
*/
rb_gc();
rv = OCIStmtExecute_nb(arg->svcctx, arg->svcctx->base.hp.svc, arg->stmtp, oci8_errhp, 1, 0, NULL, NULL, OCI_DEFAULT);
}
}
if (arg->raise_on_error) {
chker3(rv, &arg->svcctx->base, arg->stmtp);
}
return (VALUE)rv;
}
/*
=begin
--- OCIStmt#prepare(stmt [, language [, mode]])
set and prepare SQL statement.
:stmt
SQL or PL/SQL statement
:language
((|OCI_NTV_SYNTAX|)), ((|OCI_V7_SYNTAX|)), or ((|OCI_V8_SYNTAX|)).
Default value is ((|OCI_NTV_SYNTAX|))
:mode
((|OCI_DEFAULT|)) or ((|OCI_NO_SHARING|)). Default value is ((|OCI_DEFAULT|)).
((|OCI_NO_SHARING|)) disables ((<Shared Data Mode>)) for this statement.
correspond native OCI function: ((|OCIStmtPrepare|))
=end
*/
static VALUE oci8_stmt_prepare(int argc, VALUE *argv, VALUE self)
{
VALUE vsql, vlanguage, vmode;
oci8_handle_t *h;
oci8_string_t s;
ub4 language;
ub4 mode;
sword rv;
VALUE ary;
VALUE hash;
int i;
rb_scan_args(argc, argv, "12", &vsql, &vlanguage, &vmode);
Get_Handle(self, h); /* 0 */
Get_String(vsql, s); /* 1 */
Get_Int_With_Default(argc, 2, vlanguage, language, OCI_NTV_SYNTAX); /* 2 */
Get_Int_With_Default(argc, 3, vmode, mode, OCI_DEFAULT); /* 3 */
/* when a new statement is prepared, OCI implicitly free the previous
* statement's define and bind handles.
* But ruby's object don't know it. So free these handles in advance.
*/
/* free define handles */
ary = rb_ivar_get(self, oci8_id_define_array);
if (ary != Qnil) {
for (i = 0;i < RARRAY_LEN(ary);i++) {
if (RARRAY_PTR(ary)[i] != Qnil)
oci8_handle_free(RARRAY_PTR(ary)[i]);
}
rb_ivar_set(self, oci8_id_define_array, Qnil);
}
/* free bind handles */
hash = rb_ivar_get(self, oci8_id_bind_hash);
if (hash != Qnil) {
rb_iterate(oci8_each_value, hash, oci8_handle_free, Qnil);
rb_ivar_set(self, oci8_id_bind_hash, Qnil);
}
rv = OCIStmtPrepare(h->hp, h->errhp, s.ptr, s.len, language, mode);
if (IS_OCI_ERROR(rv)) {
oci8_raise(h->errhp, rv, h->hp);
}
return self;
}
void OraSession::issueStatement(const std::string& stmt) {
try {
if(checkerr(&ociHandles, OCIStmtPrepare(ociHandles.stmthp, ociHandles.errhp, (text*)stmt.c_str(),
(ub4)strlen(stmt.c_str()), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT)) != 0) {
std::cout << "OCIStmtPrepare((dvoid *)ociHandles.envhp, (dvoid **)&stmthp failed." << std::endl << std::endl;
return;
}
if(checkerr(&ociHandles, OCIStmtExecute(ociHandles.svchp, ociHandles.stmthp, ociHandles.errhp, (ub4)1, (ub4)0,
(OCISnapshot *)NULL, (OCISnapshot *)NULL, (ub4)OCI_DEFAULT)) != 0) {
std::cout << "OCIStmtExecute((dvoid *)ociHandles.envhp, (dvoid **)&stmthp failed." << std::endl << std::endl;
return;
}
} catch(std::runtime_error e) {
throw std::runtime_error("Error executing Statement: " + stmt + "\n" + e.what());
}
}
JP_INTERNAL(int) JP_Open(TJQuery &qry, const text* Query)
{
if (qry.isOpen == 0)
{
qry.conn.result = OCIHandleAlloc(qry.conn.ociEnv,
(void**)&qry.ociStmt,
OCI_HTYPE_STMT,
0, 0);
if (qry.conn.result == 0)
qry.conn.result = OCIStmtPrepare(qry.ociStmt,
qry.conn.ociError,
TJ_CAST Query,
strlen((char*)Query),
OCI_NTV_SYNTAX,
OCI_DEFAULT);
if (qry.conn.result == 0)
qry.isOpen = 1;
}
return _Result(qry);
}
PreparedStatement_T OracleConnection_prepareStatement(T C, const char *sql, va_list ap) {
OCIStmt *stmtp;
va_list ap_copy;
assert(C);
va_copy(ap_copy, ap);
StringBuffer_vset(C->sb, sql, ap_copy);
va_end(ap_copy);
StringBuffer_trim(C->sb);
int paramCount = StringBuffer_prepare4oracle(C->sb);
/* Build statement */
C->lastError = OCIHandleAlloc(C->env, (void **)&stmtp, OCI_HTYPE_STMT, 0, 0);
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;
}
return PreparedStatement_new(OraclePreparedStatement_new(stmtp, C->env, C->usr, C->err, C->svc, C->maxRows), (Pop_T)&oraclepops, paramCount);
}
/*************************************************************************
*
* Function: sql_query
*
* Purpose: Issue a non-SELECT query (ie: update/delete/insert) to
* the database.
*
*************************************************************************/
static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
int x;
rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
if (config->sqltrace)
DEBUG(querystr);
if (oracle_sock->conn == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
return SQL_DOWN;
}
if (OCIStmtPrepare (oracle_sock->queryHandle, oracle_sock->errHandle,
querystr, strlen(querystr),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_query: %s",sql_error(sqlsocket, config));
return -1;
}
x = OCIStmtExecute(oracle_sock->conn,
oracle_sock->queryHandle,
oracle_sock->errHandle,
(ub4) 1,
(ub4) 0,
(OCISnapshot *) NULL,
(OCISnapshot *) NULL,
(ub4) OCI_COMMIT_ON_SUCCESS);
if (x == OCI_SUCCESS) {
return 0;
}
if (x == OCI_ERROR) {
radlog(L_ERR,"rlm_sql_oracle: execute query failed in sql_query: %s",
sql_error(sqlsocket, config));
return sql_check_error(sqlsocket, config);
}
else {
return -1;
}
}
/* 执行 SQL语句 */
int ltDbExecSql0(ltDbConn *pConn,char *pSmt,int iSumBind,...)
{
DB_CURSOR *psCur;
int status;
va_list ap;
psCur = dbOpen(pConn);
if(psCur == NULL) {
return -1;
}
status = OCIStmtPrepare(psCur->pStmt, psCur->pConn->pErr, pSmt,
(ub4)strlen(pSmt),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
if(status != OCI_SUCCESS) {
status = ltDbErrorCode(pConn);
dbClose(psCur);
return status;
}
va_start(ap,iSumBind);
status = _ltDbSetBindValue_o(pConn,psCur,iSumBind,&ap);
va_end(ap);
if(status != 0) {
status = ltDbErrorCode(pConn);
dbClose(psCur);
return status;
}
status = OCIStmtExecute(psCur->pConn->pSvc, psCur->pStmt, psCur->pConn->pErr,
1, (ub4)0, (OCISnapshot*)0, (OCISnapshot*)0, OCI_DEFAULT);
if(status == OCI_SUCCESS) {
/* 网文件中写日志 */
dbClose(psCur);
return 0;
}
else {
status = ltDbErrorCode(pConn);
dbClose(psCur);
return status;
}
}
/*************************************************************************
*
* Function: sql_query
*
* Purpose: Issue a non-SELECT query (ie: update/delete/insert) to
* the database.
*
*************************************************************************/
static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
int x;
rlm_sql_oracle_conn_t *conn = handle->conn;
if (conn->ctx == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
return SQL_DOWN;
}
if (OCIStmtPrepare (conn->queryHandle, conn->errHandle,
querystr, strlen(querystr),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_query: %s",sql_error(handle, config));
return -1;
}
x = OCIStmtExecute(conn->ctx,
conn->queryHandle,
conn->errHandle,
(ub4) 1,
(ub4) 0,
(OCISnapshot *) NULL,
(OCISnapshot *) NULL,
(ub4) OCI_COMMIT_ON_SUCCESS);
if (x == OCI_SUCCESS) {
return 0;
}
if (x == OCI_ERROR) {
radlog(L_ERR,"rlm_sql_oracle: execute query failed in sql_query: %s",
sql_error(handle, config));
return sql_check_error(handle, config);
}
else {
return -1;
}
}
/* execute an SQL statement for the given service context */
static int doSql(OCISvcCtx *svcCtx, OCIStmt *stmthp, OCIError *errhp, text *sql, int empno) {
OCIBind *bndp = (OCIBind *) 0;
sword status = OCIStmtPrepare(stmthp, errhp, (text *) sql, (ub4) strlen((char *)sql),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT);
btlogger_debug( "TxLog executing statement: %s :1=%d", sql, empno);
/* bind empno to the statement */
if (empno > 0 && status == OCI_SUCCESS)
status = OCIBindByPos(stmthp, &bndp, errhp, 1, (dvoid *) &empno, (sword) sizeof (empno),
SQLT_INT, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
if (status == OCI_SUCCESS)
status = OCIStmtExecute(svcCtx, stmthp, errhp, (ub4) 1, (ub4) 0,
(CONST OCISnapshot *) NULL,
(OCISnapshot *) NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS)
show_error(errhp, status);
return status;
}
std::string OraSession::getPasswordForUser(const std::string& user) {
char password[4096];
OCIBind *bnd1p = 0;
std::string stmt = "begin select password into :password from sys.dba_users where username = upper('" + user + "'); end;";
checkerr(&ociHandles, OCIStmtPrepare(ociHandles.stmthp, ociHandles.errhp, (text*)stmt.c_str(),
(ub4)strlen(stmt.c_str()), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT));
password[0] = 0;
checkerr(&ociHandles, OCIBindByName(ociHandles.stmthp, (OCIBind **)&bnd1p, ociHandles.errhp,
(text *)":password", (sb4)strlen(":password"),
(dvoid *)password, (sb4)4096, SQLT_STR, (dvoid *)0,
(ub2 *)0, (ub2 *)0, (ub4)0, (ub4 *)0,(ub4)OCI_DEFAULT));
checkerr(&ociHandles, OCIStmtExecute(ociHandles.svchp, ociHandles.stmthp, ociHandles.errhp, (ub4)1, (ub4)0, (OCISnapshot *)NULL,
(OCISnapshot *)NULL, (ub4)OCI_DEFAULT));
return password;
}
CPLErr OGROCIStatement::Prepare( const char *pszSQLStatement )
{
Clean();
CPLDebug( "OCI", "Prepare(%s)", pszSQLStatement );
pszCommandText = CPLStrdup(pszSQLStatement);
if( hStatement != NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Statement already executed once on this OGROCIStatement." );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Allocate a statement handle. */
/* -------------------------------------------------------------------- */
if( poSession->Failed(
OCIHandleAlloc( poSession->hEnv, (dvoid **) &hStatement,
(ub4)OCI_HTYPE_STMT,(size_t)0, (dvoid **)0 ),
"OCIHandleAlloc(Statement)" ) )
return CE_Failure;
/* -------------------------------------------------------------------- */
/* Prepare the statement. */
/* -------------------------------------------------------------------- */
if( poSession->Failed(
OCIStmtPrepare( hStatement, poSession->hError,
(text *) pszSQLStatement, strlen(pszSQLStatement),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT ),
"OCIStmtPrepare" ) )
return CE_Failure;
return CE_None;
}
/* ODCIIndexInsert function */
OCINumber *qxiqtbspi(
OCIExtProcContext *ctx,
ODCIIndexInfo *ix,
ODCIIndexInfo_ind *ix_ind,
char *rid,
short rid_ind,
char *newval,
short newval_ind,
ODCIEnv *env,
ODCIEnv_ind *env_ind)
{
OCIEnv *envhp = (OCIEnv *) 0; /* env. handle */
OCISvcCtx *svchp = (OCISvcCtx *) 0; /* service handle */
OCIError *errhp = (OCIError *) 0; /* error handle */
OCIStmt *stmthp = (OCIStmt *) 0; /* statement handle */
OCIBind *bndp = (OCIBind *) 0; /* bind handle */
int retval = (int)ODCI_SUCCESS; /* return from this function */
OCINumber *rval = (OCINumber *)0;
char insstmt[2000]; /* sql insert statement */
ODCIColInfo *colinfo; /* column info */
ODCIColInfo_ind *colinfo_ind;
boolean exists = TRUE;
int partiden; /* table partition iden */
/* allocate memory for OCINumber first */
rval = (OCINumber *)OCIExtProcAllocCallMemory(ctx, sizeof(OCINumber));
/* Get oci handles */
if (qxiqtce(ctx, errhp, OCIExtProcGetEnv(ctx, &envhp, &svchp, &errhp)))
return(rval);
/* set up return code */
if (qxiqtce(ctx, errhp, OCINumberFromInt(errhp, (dvoid *)&retval,
sizeof(retval),
OCI_NUMBER_SIGNED, rval)))
return(rval);
/******************************
* Construct insert Statement *
******************************/
if ( ix_ind->IndexPartitionIden == OCI_IND_NULL )
(void)sprintf(insstmt,
"INSERT into %s.%s_sbtree values (:newval, :mrid)",
OCIStringPtr(envhp, ix->IndexSchema),
OCIStringPtr(envhp, ix->IndexName));
else
{
if (qxiqtce(ctx, errhp, OCICollGetElem(envhp, errhp,
(OCIColl *)ix->IndexCols, (sb4)0, &exists,
(void **) &colinfo, (void **) &colinfo_ind)))
return(rval);
(void)sprintf(insstmt,
"INSERT into %s.%s_sbtree partition (DATAOBJ_TO_PARTITION(%s, :partiden)) values (:newval, :mrid)",
OCIStringPtr(envhp, ix->IndexSchema),
OCIStringPtr(envhp, ix->IndexName),
OCIStringPtr(envhp, colinfo->TableName));
}
/****************************************
* Parse and Execute Create Statement *
****************************************/
/* allocate stmt handle */
if (qxiqtce(ctx, errhp, OCIHandleAlloc((dvoid *)envhp,
(dvoid **)&stmthp,
(ub4)OCI_HTYPE_STMT, (size_t)0,
(dvoid **)0)))
return(rval);
/* prepare the statement */
if (qxiqtce(ctx, errhp, OCIStmtPrepare(stmthp, errhp,
(text *)insstmt,
(ub4)strlen(insstmt),
OCI_NTV_SYNTAX,
OCI_DEFAULT)))
return(rval);
if (ix_ind->IndexPartitionIden != OCI_IND_NULL)
{
/* Convert partiden to integer from OCINumber */
if (qxiqtce(ctx, errhp, OCINumberToInt(errhp,
&(colinfo->TablePartitionIden),
sizeof(partiden),
OCI_NUMBER_SIGNED,
( void *)&partiden)))
return(rval);
/* Set up bind for partiden */
if (qxiqtce(ctx, errhp, OCIBindByName(stmthp, &bndp, errhp,
(text *)":partiden",
sizeof(":partiden")-1,
(dvoid *)&partiden,
(sb4)(sizeof(partiden)),
(ub2)SQLT_INT,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0,
(ub4)OCI_DEFAULT)))
return(rval);
}
/* Set up bind for newval */
if (qxiqtce(ctx, errhp, OCIBindByName(stmthp, &bndp, errhp,
(text *)":newval",
sizeof(":newval")-1,
(dvoid *)newval,
(sb4)(strlen(newval)+1),
(ub2)SQLT_STR,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0,
(ub4)OCI_DEFAULT)))
return(rval);
/* Set up bind for rid */
if (qxiqtce(ctx, errhp, OCIBindByName(stmthp, &bndp, errhp,
(text *)":mrid",
sizeof(":mrid")-1,
(dvoid *)rid,
(sb4)(strlen(rid)+1),
(ub2)SQLT_STR,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0,
(ub4)OCI_DEFAULT)))
return(rval);
/* Execute statement */
if (qxiqtce(ctx, errhp, OCIStmtExecute(svchp, stmthp, errhp, (ub4)1,
(ub4)0, (OCISnapshot *)NULL,
(OCISnapshot *)NULL,
(ub4)OCI_DEFAULT)))
return(rval);
/* free stmt handle */
if (qxiqtce(ctx, errhp, OCIHandleFree((dvoid *)stmthp,
(ub4)OCI_HTYPE_STMT)))
return(rval);
return(rval);
}
/*
* Execute SQL statement. For non-select statements only.
*/
int zbx_db_vexecute(const char *fmt, va_list args)
{
char *sql = NULL;
int ret = ZBX_DB_OK;
double sec = 0;
#if defined(HAVE_IBM_DB2)
SQLHANDLE hstmt = 0;
SQLRETURN ret1;
SQLLEN row1;
SQLLEN rows = 0;
#elif defined(HAVE_MYSQL)
int status;
#elif defined(HAVE_ORACLE)
OCIStmt *stmthp = NULL;
sword err = OCI_SUCCESS;
#elif defined(HAVE_POSTGRESQL)
PGresult *result;
char *error = NULL;
#elif defined(HAVE_SQLITE3)
int err;
char *error = NULL;
#endif
if (0 != CONFIG_LOG_SLOW_QUERIES)
sec = zbx_time();
sql = zbx_dvsprintf(sql, fmt, args);
if (0 == txn_init && 0 == txn_level)
zabbix_log(LOG_LEVEL_DEBUG, "query without transaction detected");
if (1 == txn_error)
{
zabbix_log(LOG_LEVEL_DEBUG, "ignoring query [txnlev:%d] [%s] within failed transaction", txn_level, sql);
ret = ZBX_DB_FAIL;
goto clean;
}
zabbix_log(LOG_LEVEL_DEBUG, "query [txnlev:%d] [%s]", txn_level, sql);
#if defined(HAVE_IBM_DB2)
/* allocate a statement handle */
if (SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_STMT, ibm_db2.hdbc, &hstmt)))
ret = ZBX_DB_DOWN;
/* directly execute the statement; returns SQL_NO_DATA_FOUND when no rows were affected */
if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success_ext(SQLExecDirect(hstmt, (SQLCHAR *)sql, SQL_NTS)))
ret = ZBX_DB_DOWN;
/* get number of affected rows */
if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLRowCount(hstmt, &rows)))
ret = ZBX_DB_DOWN;
/* process other SQL statements in the batch */
while (ZBX_DB_OK == ret && SUCCEED == zbx_ibm_db2_success(ret1 = SQLMoreResults(hstmt)))
{
if (SUCCEED != zbx_ibm_db2_success(SQLRowCount(hstmt, &row1)))
ret = ZBX_DB_DOWN;
else
rows += row1;
}
if (ZBX_DB_OK == ret && SQL_NO_DATA_FOUND != ret1)
ret = ZBX_DB_DOWN;
if (ZBX_DB_OK != ret)
{
zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);
zbx_ibm_db2_log_errors(SQL_HANDLE_STMT, hstmt);
ret = (SQL_CD_TRUE == IBM_DB2server_status() ? ZBX_DB_FAIL : ZBX_DB_DOWN);
}
else if (0 <= rows)
{
ret = (int)rows;
}
if (hstmt)
SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
#elif defined(HAVE_MYSQL)
if (NULL == conn)
{
zabbix_errlog(ERR_Z3003);
ret = ZBX_DB_FAIL;
}
else
{
if (0 != (status = mysql_query(conn, sql)))
{
zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);
switch (mysql_errno(conn))
{
case CR_CONN_HOST_ERROR:
case CR_SERVER_GONE_ERROR:
case CR_CONNECTION_ERROR:
case CR_SERVER_LOST:
case ER_SERVER_SHUTDOWN:
case ER_ACCESS_DENIED_ERROR: /* wrong user or password */
case ER_ILLEGAL_GRANT_FOR_TABLE: /* user without any privileges */
case ER_TABLEACCESS_DENIED_ERROR:/* user without some privilege */
case ER_UNKNOWN_ERROR:
ret = ZBX_DB_DOWN;
break;
default:
ret = ZBX_DB_FAIL;
break;
}
}
else
{
do
{
if (0 != mysql_field_count(conn))
{
zabbix_log(LOG_LEVEL_DEBUG, "cannot retrieve result set");
break;
}
else
ret += (int)mysql_affected_rows(conn);
/* more results? -1 = no, >0 = error, 0 = yes (keep looping) */
if (0 < (status = mysql_next_result(conn)))
zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);
}
while (0 == status);
}
}
#elif defined(HAVE_ORACLE)
err = OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&stmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);
if (OCI_SUCCESS == err)
{
err = OCIStmtPrepare(stmthp, oracle.errhp, (text *)sql, (ub4)strlen((char *)sql),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
}
if (OCI_SUCCESS == err)
{
err = OCIStmtExecute(oracle.svchp, stmthp, oracle.errhp, (ub4)1, (ub4)0,
(CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_COMMIT_ON_SUCCESS);
if (OCI_SUCCESS == err)
{
ub4 nrows = 0;
err = OCIAttrGet((void *)stmthp, OCI_HTYPE_STMT, (ub4 *)&nrows,
(ub4 *)0, OCI_ATTR_ROW_COUNT, oracle.errhp);
ret = nrows;
}
}
if (OCI_SUCCESS != err)
{
zabbix_errlog(ERR_Z3005, err, zbx_oci_error(err), sql);
ret = (OCI_SERVER_NORMAL == OCI_DBserver_status() ? ZBX_DB_FAIL : ZBX_DB_DOWN);
}
if (NULL != stmthp)
{
(void)OCIHandleFree((dvoid *)stmthp, OCI_HTYPE_STMT);
stmthp = NULL;
}
#elif defined(HAVE_POSTGRESQL)
result = PQexec(conn,sql);
if (NULL == result)
{
zabbix_errlog(ERR_Z3005, 0, "result is NULL", sql);
ret = (CONNECTION_OK == PQstatus(conn) ? ZBX_DB_FAIL : ZBX_DB_DOWN);
}
else if (PGRES_COMMAND_OK != PQresultStatus(result))
{
error = zbx_dsprintf(error, "%s:%s",
PQresStatus(PQresultStatus(result)),
PQresultErrorMessage(result));
zabbix_errlog(ERR_Z3005, 0, error, sql);
zbx_free(error);
ret = (CONNECTION_OK == PQstatus(conn) ? ZBX_DB_FAIL : ZBX_DB_DOWN);
}
if (ZBX_DB_OK == ret)
ret = atoi(PQcmdTuples(result));
PQclear(result);
#elif defined(HAVE_SQLITE3)
if (0 == txn_level && PHP_MUTEX_OK != php_sem_acquire(&sqlite_access))
{
zabbix_log(LOG_LEVEL_CRIT, "ERROR: cannot create lock on SQLite3 database");
exit(FAIL);
}
lbl_exec:
if (SQLITE_OK != (err = sqlite3_exec(conn, sql, NULL, 0, &error)))
{
if (SQLITE_BUSY == err)
goto lbl_exec;
zabbix_errlog(ERR_Z3005, 0, error, sql);
sqlite3_free(error);
switch (err)
{
case SQLITE_ERROR: /* SQL error or missing database; assuming SQL error, because if we
are this far into execution, zbx_db_connect() was successful */
case SQLITE_NOMEM: /* A malloc() failed */
case SQLITE_TOOBIG: /* String or BLOB exceeds size limit */
case SQLITE_CONSTRAINT: /* Abort due to constraint violation */
case SQLITE_MISMATCH: /* Data type mismatch */
ret = ZBX_DB_FAIL;
break;
default:
ret = ZBX_DB_DOWN;
break;
}
}
if (ZBX_DB_OK == ret)
ret = sqlite3_changes(conn);
if (0 == txn_level)
php_sem_release(&sqlite_access);
#endif /* HAVE_SQLITE3 */
if (0 != CONFIG_LOG_SLOW_QUERIES)
{
sec = zbx_time() - sec;
if (sec > (double)CONFIG_LOG_SLOW_QUERIES / 1000.0)
zabbix_log(LOG_LEVEL_WARNING, "slow query: " ZBX_FS_DBL " sec, \"%s\"", sec, sql);
}
if (ZBX_DB_FAIL == ret && 0 < txn_level)
{
zabbix_log(LOG_LEVEL_DEBUG, "query [%s] failed, setting transaction as failed", sql);
txn_error = 1;
}
clean:
zbx_free(sql);
return ret;
}
int FC_FUNC_(oraclesim_getdatahead, ORACLESIM_GETDATAHEAD)
(OracleDbConnection **fdbconnid, char *ti, char *tf,
int *net, int *var, int *nvar) {
OracleDbConnection *dbconnid = *fdbconnid;
int i;
char *query;
/* valori validi =1, mancanti =-1, inutilizzati per ora, ci pensa la query */
/* sb2 otab_ind, ovalp_ind, ovala_ind, oflag_ind; */
char odate[DATELEN], ovalc[CVALLEN], oflag[FLAGLEN];
int ostatid, ovarid;
float ovalp, ovala;
/* Eseguo l'estrazione per ottenere il nome della tabella,
complicazione per colpa di CAELAMI */
if ((i = gettab(dbconnid, var, *nvar, net)) != 0) return i;
/* Ricostruisco la richiesta dati con il nome della tabella ottenuto */
query = alloca(strlen(query1)+strlen(dbconnid->table)+strlen(query2)+
10*(*nvar+1)+strlen(query3)+1);
strcpy(query, query1);
strcat(query, dbconnid->table);
strcat(query, query2);
if (*nvar > 1) {
strcat(query, " IN (");
for (i=0; i < (*nvar); i++) {
snprintf(query+strlen(query), 10, "%d", var[i]);
if (i < (*nvar)-1) strcat(query, ",");
}
strcat(query, ")");
} else {
strcat(query, " = ");
snprintf(query+strlen(query), 10, "%d", *var);
}
strcat(query, query3);
/* Preparo l'estrazione dati */
checkerr(dbconnid, OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) query,
(ub4) strlen(query),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
checkerr(dbconnid, OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":ti",
-1, (dvoid *) ti,
DATELEN, SQLT_STR, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid, OCIBindByName(dbconnid->stmthp, &dbconnid->bnd2p,
dbconnid->errhp, (text *) ":tf",
-1, (dvoid *) tf,
DATELEN, SQLT_STR, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid, OCIBindByName(dbconnid->stmthp, &dbconnid->bnd3p,
dbconnid->errhp, (text *) ":net",
-1, (dvoid *) net,
(sword) sizeof(*net), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
/* definisco l'uscita */
datadefine(dbconnid, odate, DATELEN, &ostatid, &ovarid, &ovalp, &ovala, ovalc, oflag, CVALLEN, FLAGLEN);
return countrows(dbconnid);
}
/* ODCIIndexStart function */
OCINumber *qxiqtbsps(
OCIExtProcContext *ctx,
qxiqtim *sctx,
qxiqtin *sctx_ind,
ODCIIndexInfo *ix,
ODCIIndexInfo_ind *ix_ind,
ODCIPredInfo *pr,
ODCIPredInfo_ind *pr_ind,
ODCIQueryInfo *qy,
ODCIQueryInfo_ind *qy_ind,
OCINumber *strt,
short strt_ind,
OCINumber *stop,
short stop_ind,
char *cmpval,
short cmpval_ind,
ODCIEnv *env,
ODCIEnv_ind *env_ind)
{
sword status;
OCIEnv *envhp = (OCIEnv *) 0; /* env. handle */
OCISvcCtx *svchp = (OCISvcCtx *) 0; /* service handle */
OCIError *errhp = (OCIError *) 0; /* error handle */
OCISession *usrhp = (OCISession *) 0; /* user handle */
qxiqtcx *icx = (qxiqtcx *) 0; /* state to be saved for later calls */
int strtval; /* start bound */
int stopval; /* stop bound */
int errnum = 29400; /* choose some oracle error number */
char errmsg[512]; /* error message buffer */
size_t errmsglen; /* Length of error message */
char relop[3]; /* relational operator used in sql stmt */
char selstmt[2000]; /* sql select statement */
int retval = (int)ODCI_SUCCESS; /* return from this function */
OCINumber *rval = (OCINumber *)0;
ub4 key; /* key value set in "sctx" */
ub1 *rkey; /* key to retrieve context */
ub4 rkeylen; /* length of key */
ODCIColInfo *colinfo; /* column info */
ODCIColInfo_ind *colinfo_ind;
boolean exists = TRUE;
int partiden; /* table partition iden */
/* Get oci handles */
if (qxiqtce(ctx, errhp, OCIExtProcGetEnv(ctx, &envhp, &svchp, &errhp)))
return(rval);
/* set up return code */
rval = (OCINumber *)OCIExtProcAllocCallMemory(ctx, sizeof(OCINumber));
if (qxiqtce(ctx, errhp, OCINumberFromInt(errhp, (dvoid *)&retval,
sizeof(retval),
OCI_NUMBER_SIGNED, rval)))
return(rval);
/* get the user handle */
if (qxiqtce(ctx, errhp, OCIAttrGet((dvoid *)svchp, (ub4)OCI_HTYPE_SVCCTX,
(dvoid *)&usrhp, (ub4 *)0,
(ub4)OCI_ATTR_SESSION,
errhp)))
return(rval);
/**********************************************/
/* Allocate memory to hold index scan context */
/**********************************************/
if (sctx_ind ->atomic_qxiqtin == OCI_IND_NULL ||
sctx_ind ->scind_qxiqtin == OCI_IND_NULL)
{
if (qxiqtce(ctx, errhp, OCIMemoryAlloc((dvoid *)usrhp, errhp,
(dvoid **)&icx,
OCI_DURATION_STATEMENT,
(ub4)(sizeof(qxiqtcx)),
OCI_MEMORY_CLEARED)))
return(rval);
icx->stmthp = (OCIStmt *)0;
icx->defnp = (OCIDefine *)0;
icx->bndp = (OCIBind *)0;
}
else
{
/*************************/
/* Retrieve scan context */
/*************************/
rkey = OCIRawPtr(envhp, sctx->sctx_qxiqtim);
rkeylen = OCIRawSize(envhp, sctx->sctx_qxiqtim);
if (qxiqtce(ctx, errhp, OCIContextGetValue((dvoid *)usrhp, errhp,
rkey, (ub1)rkeylen,
(dvoid **)&(icx))))
return(rval);
}
/***********************************/
/* Check that the bounds are valid */
/***********************************/
/* convert from oci numbers to native numbers */
if (qxiqtce(ctx, errhp, OCINumberToInt(errhp, strt,
sizeof(strtval),
OCI_NUMBER_SIGNED,
(dvoid *)&strtval)))
return(rval);
if (qxiqtce(ctx, errhp, OCINumberToInt(errhp, stop,
sizeof(stopval),
OCI_NUMBER_SIGNED,
(dvoid *)&stopval)))
return(rval);
/* verify that strtval/stopval are both either 0 or 1 */
if (!(((strtval == 0) && (stopval == 0)) ||
((strtval == 1) && (stopval == 1))))
{
strcpy(errmsg, (char *)"Incorrect predicate for sbtree operator");
errmsglen = (size_t)strlen(errmsg);
if (OCIExtProcRaiseExcpWithMsg(ctx, errnum, (text *)errmsg, errmsglen)
!= OCIEXTPROC_SUCCESS)
/* Use cartridge error services here */;
return(rval);
}
/*********************************************/
/* Generate the SQL statement to be executed */
/*********************************************/
if (memcmp((dvoid *)OCIStringPtr(envhp, pr->ObjectName), (dvoid *)"EQ", 2)
== 0)
if (strtval == 1)
strcpy(relop, (char *)"=");
else
strcpy(relop, (char *)"!=");
else if (memcmp((dvoid *)OCIStringPtr(envhp, pr->ObjectName), (dvoid *)"LT",
2) == 0)
if (strtval == 1)
strcpy(relop, (char *)"<");
else
strcpy(relop, (char *)">=");
else
if (strtval == 1)
strcpy(relop, (char *)">");
else
strcpy(relop, (char *)"<=");
if (ix_ind->IndexPartitionIden == OCI_IND_NULL)
(void)sprintf(selstmt, "select f2 from %s.%s_sbtree where f1 %s :val",
OCIStringPtr(envhp, ix->IndexSchema),
OCIStringPtr(envhp, ix->IndexName), relop);
else
{
if (qxiqtce(ctx, errhp, OCICollGetElem(envhp, errhp,
(OCIColl *)ix->IndexCols, (sb4)0, &exists,
(void **) &colinfo, (void **) &colinfo_ind)))
return(rval);
(void)sprintf(selstmt, "select f2 from %s.%s_sbtree partition (DATAOBJ_TO_PARTITION(%s, :partiden)) where f1 %s :val",
OCIStringPtr(envhp, ix->IndexSchema),
OCIStringPtr(envhp, ix->IndexName),
OCIStringPtr(envhp, colinfo->TableName), relop);
}
/***********************************/
/* Parse, bind, define and execute */
/***********************************/
if (sctx_ind ->atomic_qxiqtin == OCI_IND_NULL ||
sctx_ind ->scind_qxiqtin == OCI_IND_NULL)
{
/* allocate stmt handle */
if (qxiqtce(ctx, errhp, OCIHandleAlloc((dvoid *)envhp,
(dvoid **)&(icx->stmthp),
(ub4)OCI_HTYPE_STMT,
(size_t)0, (dvoid **)0)))
return(rval);
}
/* prepare the statement */
if (qxiqtce(ctx, errhp, OCIStmtPrepare(icx->stmthp, errhp,
(text *)selstmt,
(ub4)strlen(selstmt),
OCI_NTV_SYNTAX,
OCI_DEFAULT)))
return(rval);
if (ix_ind->IndexPartitionIden != OCI_IND_NULL)
{
/* Convert partiden to integer from OCINumber */
if (qxiqtce(ctx, errhp, OCINumberToInt(errhp,
&(colinfo->TablePartitionIden),
sizeof(partiden),
OCI_NUMBER_SIGNED,
( void *)&partiden)))
return(rval);
/* Set up bind for partiden */
if (qxiqtce(ctx, errhp, OCIBindByName(icx->stmthp, &(icx->bndp), errhp,
(text *)":partiden",
sizeof(":partiden")-1,
(dvoid *)&partiden,
(sb4)(sizeof(partiden)),
(ub2)SQLT_INT,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0,
(ub4)OCI_DEFAULT)))
return(rval);
}
/* Set up bind for compare value */
if (qxiqtce(ctx, errhp, OCIBindByName(icx->stmthp, &(icx->bndp),errhp,
(text *)":val",
sizeof(":val")-1,
(dvoid *)cmpval,
(sb4)(strlen(cmpval)+1),
(ub2)SQLT_STR,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0,
(ub4)OCI_DEFAULT)))
return(rval);
/* Set up define */
if (qxiqtce(ctx, errhp, OCIDefineByPos(icx->stmthp, &(icx->defnp),
errhp, (ub4)1,
(dvoid *)(icx->ridp),
(sb4) sizeof(icx->ridp),
(ub2)SQLT_STR,
(dvoid *)0, (ub2 *)0,
(ub2 *)0, (ub4)OCI_DEFAULT)))
return(rval);
/* execute */
if (qxiqtce(ctx, errhp, OCIStmtExecute(svchp, icx->stmthp,
errhp, (ub4)0,
(ub4)0, (OCISnapshot *)NULL,
(OCISnapshot *)NULL,
(ub4)OCI_DEFAULT)))
return(rval);
/************************************/
/* Set index context to be returned */
/************************************/
if (sctx_ind ->atomic_qxiqtin == OCI_IND_NULL ||
sctx_ind ->scind_qxiqtin == OCI_IND_NULL)
{
/* generate a key */
if (qxiqtce(ctx, errhp, OCIContextGenerateKey((dvoid *)usrhp,
errhp, &key)))
return(rval);
/* set the memory address of the struct to be saved in the context */
if (qxiqtce(ctx, errhp, OCIContextSetValue((dvoid *)usrhp, errhp,
OCI_DURATION_STATEMENT,
(ub1 *)&key,
(ub1)sizeof(key),
(dvoid *)icx)))
return(rval);
/* set the key as the member of "sctx" */
if (qxiqtce(ctx, errhp, OCIRawAssignBytes(envhp, errhp,
(ub1 *)&key,
(ub4)sizeof(key),
&(sctx->sctx_qxiqtim))))
return(rval);
sctx_ind->atomic_qxiqtin = OCI_IND_NOTNULL;
sctx_ind->scind_qxiqtin = OCI_IND_NOTNULL;
return(rval);
}
return(rval);
}
static int oracle_update(void *theconn, const Octstr *sql, List *binds)
{
OCIStmt *stmt;
sword status;
ub4 rows = 0, i;
struct ora_conn *conn = (struct ora_conn*) theconn;
int binds_len = (binds ? gwlist_len(binds) : 0);
/* allocate statement handle */
status = OCIHandleAlloc(conn->envp, (dvoid**)&stmt, OCI_HTYPE_STMT, 0,0);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
return -1;
}
debug("dbpool.oracle",0,"OCIStmt allocated");
/* prepare statement */
status = OCIStmtPrepare(stmt, conn->errhp, (unsigned char*)octstr_get_cstr(sql),
octstr_len(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
debug("dbpool.oracle",0,"OCIStmtPrepare done");
/* bind variables */
for (i = 0; i < binds_len; i++) {
Octstr *bind = gwlist_get(binds, i);
OCIBind *bndhp = NULL;
status = OCIBindByPos(stmt, &bndhp,
conn->errhp, (i+1), (dvoid *) octstr_get_cstr(bind),
(sword) octstr_len(bind)+1, SQLT_STR, (dvoid *) 0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
}
/* execute our statement */
status = OCIStmtExecute(conn->svchp, stmt, conn->errhp, 1, 0, NULL, NULL,
/*OCI_DEFAULT*/ OCI_COMMIT_ON_SUCCESS);
if (OCI_SUCCESS != status && OCI_NO_DATA != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
debug("dbpool.oracle",0,"OCIStmtExecute done");
/* retrieve #rows processed so far */
status = OCIAttrGet(stmt, OCI_HTYPE_STMT, &rows, 0, OCI_ATTR_ROW_COUNT,
conn->errhp);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
/* we doesn't return error here, because sql is executed and commited already */
}
debug("dbpool.oracle",0,"rows processed = %d", rows);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return (int) rows;
}
static int o_read_database_query (o_database_t *db, /* {{{ */
udb_query_t *q, udb_query_preparation_area_t *prep_area)
{
char **column_names;
char **column_values;
size_t column_num;
OCIStmt *oci_statement;
/* List of `OCIDefine' pointers. These defines map columns to the buffer
* space declared above. */
OCIDefine **oci_defines;
int status;
size_t i;
oci_statement = udb_query_get_user_data (q);
/* Prepare the statement */
if (oci_statement == NULL) /* {{{ */
{
const char *statement;
statement = udb_query_get_statement (q);
assert (statement != NULL);
status = OCIHandleAlloc (oci_env, (void *) &oci_statement,
OCI_HTYPE_STMT, /* user_data_size = */ 0, /* user_data = */ NULL);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIHandleAlloc", oci_error);
oci_statement = NULL;
return (-1);
}
status = OCIStmtPrepare (oci_statement, oci_error,
(text *) statement, (ub4) strlen (statement),
/* language = */ OCI_NTV_SYNTAX,
/* mode = */ OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIStmtPrepare", oci_error);
OCIHandleFree (oci_statement, OCI_HTYPE_STMT);
oci_statement = NULL;
return (-1);
}
udb_query_set_user_data (q, oci_statement);
DEBUG ("oracle plugin: o_read_database_query (%s, %s): "
"Successfully allocated statement handle.",
db->name, udb_query_get_name (q));
} /* }}} */
assert (oci_statement != NULL);
/* Execute the statement */
status = OCIStmtExecute (db->oci_service_context, /* {{{ */
oci_statement,
oci_error,
/* iters = */ 0,
/* rowoff = */ 0,
/* snap_in = */ NULL, /* snap_out = */ NULL,
/* mode = */ OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name, udb_query_get_name (q),
"OCIStmtExecute", oci_error);
return (-1);
} /* }}} */
/* Acquire the number of columns returned. */
do /* {{{ */
{
ub4 param_counter = 0;
status = OCIAttrGet (oci_statement, OCI_HTYPE_STMT, /* {{{ */
¶m_counter, /* size pointer = */ NULL,
OCI_ATTR_PARAM_COUNT, oci_error);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIAttrGet", oci_error);
return (-1);
} /* }}} */
column_num = (size_t) param_counter;
} while (0); /* }}} */
/* Allocate the following buffers:
*
* +---------------+-----------------------------------+
* ! Name ! Size !
* +---------------+-----------------------------------+
* ! column_names ! column_num x DATA_MAX_NAME_LEN !
* ! column_values ! column_num x DATA_MAX_NAME_LEN !
* ! oci_defines ! column_num x sizeof (OCIDefine *) !
* +---------------+-----------------------------------+
*
* {{{ */
#define NUMBER_BUFFER_SIZE 64
#define FREE_ALL \
if (column_names != NULL) { \
sfree (column_names[0]); \
sfree (column_names); \
} \
if (column_values != NULL) { \
sfree (column_values[0]); \
sfree (column_values); \
} \
sfree (oci_defines)
#define ALLOC_OR_FAIL(ptr, ptr_size) \
do { \
size_t alloc_size = (size_t) ((ptr_size)); \
(ptr) = calloc (1, alloc_size); \
if ((ptr) == NULL) { \
FREE_ALL; \
ERROR ("oracle plugin: o_read_database_query: calloc failed."); \
return (-1); \
} \
} while (0)
/* Initialize everything to NULL so the above works. */
column_names = NULL;
column_values = NULL;
oci_defines = NULL;
ALLOC_OR_FAIL (column_names, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_names[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
for (i = 1; i < column_num; i++)
column_names[i] = column_names[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (column_values, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_values[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
for (i = 1; i < column_num; i++)
column_values[i] = column_values[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (oci_defines, column_num * sizeof (OCIDefine *));
/* }}} End of buffer allocations. */
/* ``Define'' the returned data, i. e. bind the columns to the buffers
* allocated above. */
for (i = 0; i < column_num; i++) /* {{{ */
{
char *column_name;
ub4 column_name_length;
OCIParam *oci_param;
oci_param = NULL;
status = OCIParamGet (oci_statement, OCI_HTYPE_STMT, oci_error,
(void *) &oci_param, (ub4) (i + 1));
if (status != OCI_SUCCESS)
{
/* This is probably alright */
DEBUG ("oracle plugin: o_read_database_query: status = %#x (= %i);",
status, status);
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIParamGet", oci_error);
status = OCI_SUCCESS;
break;
}
column_name = NULL;
column_name_length = 0;
status = OCIAttrGet (oci_param, OCI_DTYPE_PARAM,
&column_name, &column_name_length, OCI_ATTR_NAME, oci_error);
if (status != OCI_SUCCESS)
{
OCIDescriptorFree (oci_param, OCI_DTYPE_PARAM);
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIAttrGet (OCI_ATTR_NAME)", oci_error);
continue;
}
OCIDescriptorFree (oci_param, OCI_DTYPE_PARAM);
oci_param = NULL;
/* Copy the name to column_names. Warning: The ``string'' returned by OCI
* may not be null terminated! */
memset (column_names[i], 0, DATA_MAX_NAME_LEN);
if (column_name_length >= DATA_MAX_NAME_LEN)
column_name_length = DATA_MAX_NAME_LEN - 1;
memcpy (column_names[i], column_name, column_name_length);
column_names[i][column_name_length] = 0;
DEBUG ("oracle plugin: o_read_database_query: column_names[%zu] = %s; "
"column_name_length = %"PRIu32";",
i, column_names[i], (uint32_t) column_name_length);
status = OCIDefineByPos (oci_statement,
&oci_defines[i], oci_error, (ub4) (i + 1),
column_values[i], DATA_MAX_NAME_LEN, SQLT_STR,
NULL, NULL, NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIDefineByPos", oci_error);
continue;
}
} /* for (j = 1; j <= param_counter; j++) */
/* }}} End of the ``define'' stuff. */
status = udb_query_prepare_result (q, prep_area,
(db->host != NULL) ? db->host : hostname_g,
/* plugin = */ "oracle", db->name, column_names, column_num,
/* interval = */ 0);
if (status != 0)
{
ERROR ("oracle plugin: o_read_database_query (%s, %s): "
"udb_query_prepare_result failed.",
db->name, udb_query_get_name (q));
FREE_ALL;
return (-1);
}
/* Fetch and handle all the rows that matched the query. */
while (42) /* {{{ */
{
status = OCIStmtFetch2 (oci_statement, oci_error,
/* nrows = */ 1, /* orientation = */ OCI_FETCH_NEXT,
/* fetch offset = */ 0, /* mode = */ OCI_DEFAULT);
if (status == OCI_NO_DATA)
{
status = OCI_SUCCESS;
break;
}
else if ((status != OCI_SUCCESS) && (status != OCI_SUCCESS_WITH_INFO))
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIStmtFetch2", oci_error);
break;
}
status = udb_query_handle_result (q, prep_area, column_values);
if (status != 0)
{
WARNING ("oracle plugin: o_read_database_query (%s, %s): "
"udb_query_handle_result failed.",
db->name, udb_query_get_name (q));
}
} /* }}} while (42) */
/* DEBUG ("oracle plugin: o_read_database_query: This statement succeeded: %s", q->statement); */
FREE_ALL;
return (0);
#undef FREE_ALL
#undef ALLOC_OR_FAIL
} /* }}} int o_read_database_query */
static int oracle_select(void *theconn, const Octstr *sql, List *binds, List **res)
{
List *row;
OCIStmt *stmt;
OCIParam *dparam;
sword status;
ub4 columns;
ub4 i;
struct data_s {
text *data;
ub2 size;
sb2 ind;
ub2 type;
};
struct data_s *data;
struct ora_conn *conn = (struct ora_conn*) theconn;
int binds_len = (binds ? gwlist_len(binds) : 0);
*res = NULL;
/* allocate statement handle */
status = OCIHandleAlloc(conn->envp, (dvoid**)&stmt, OCI_HTYPE_STMT, 0,0);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
return -1;
}
/* prepare statement */
status = OCIStmtPrepare(stmt, conn->errhp, (unsigned char*)octstr_get_cstr(sql),
octstr_len(sql), OCI_NTV_SYNTAX, OCI_DEFAULT);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
/* bind variables */
for (i = 0; i < binds_len; i++) {
OCIBind *bndhp = NULL;
Octstr *bind = gwlist_get(binds, i);
status = OCIBindByPos(stmt, &bndhp,
conn->errhp, (i+1), (dvoid *) octstr_get_cstr(bind),
(sword) octstr_len(bind)+1, SQLT_STR, (dvoid *) 0, (ub2 *)0,
(ub2 *)0, (ub4)0, (ub4 *)0, OCI_DEFAULT);
if (OCI_SUCCESS != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
}
/* execute our statement */
status = OCIStmtExecute(conn->svchp, stmt, conn->errhp, 0, 0, NULL, NULL,
OCI_DEFAULT);
if (OCI_SUCCESS != status && OCI_NO_DATA != status) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
/* receive column count */
status = OCIAttrGet(stmt, OCI_HTYPE_STMT, &columns, 0, OCI_ATTR_PARAM_COUNT,
conn->errhp);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
debug("dbpool.oracle",0,"SQL has %d columns", columns);
/* allocate array of pointers */
debug("dbpool.oracle",0,"alloc size=%ld",sizeof(text*)*columns);
data = gw_malloc(sizeof(struct data_s)*columns);
debug("dbpool.oracle",0,"retrieve data_size");
/* retrieve data size for every column and allocate it */
for (i=0 ; i < columns; i++) {
OCIDefine *defh;
status = OCIParamGet(stmt, OCI_HTYPE_STMT, conn->errhp,
(dvoid**) &dparam, i+1);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
columns = i;
for (i = 0; i < columns; i++)
gw_free(data[i].data);
gw_free(data);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
status = OCIAttrGet(dparam, OCI_DTYPE_PARAM, (dvoid*) &data[i].size,
0, OCI_ATTR_DATA_SIZE, conn->errhp);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
columns = i;
for (i = 0; i < columns; i++)
gw_free(data[i].data);
gw_free(data);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
status = OCIAttrGet(dparam, OCI_DTYPE_PARAM, (dvoid*) &data[i].type,
0, OCI_ATTR_DATA_TYPE, conn->errhp);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
columns = i;
for (i = 0; i < columns; i++)
gw_free(data[i].data);
gw_free(data);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
/* convert all data types to C-Strings except DATE */
if (data[i].type != SQLT_DAT) {
data[i].size++; /* terminating zero */
data[i].type = SQLT_STR;
}
debug("dbpool.oracle",0,"alloc size=%d", data[i].size);
data[i].data = gw_malloc(data[i].size);
/* bind allocated values to statement handle */
status = OCIDefineByPos(stmt, &defh, conn->errhp, i+1, data[i].data,
data[i].size, data[i].type, &data[i].ind,
0, 0, OCI_DEFAULT);
if (status != OCI_SUCCESS) {
oracle_checkerr(conn->errhp, status);
columns = i;
for (i = 0; i <= columns; i++)
gw_free(data[i].data);
gw_free(data);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
}
*res = gwlist_create();
/* fetch data */
while ((status = OCIStmtFetch(stmt, conn->errhp, 1,
OCI_FETCH_NEXT, OCI_DEFAULT)) == OCI_SUCCESS ||
status == OCI_SUCCESS_WITH_INFO) {
row = gwlist_create();
for (i = 0; i < columns; i++) {
if (data[i].data == NULL || data[i].ind == -1) {
gwlist_insert(row, i, octstr_create(""));
} else {
gwlist_insert(row, i, octstr_create_from_data((const char*)data[i].data, data[i].size));
}
/* debug("dbpool.oracle",0,"inserted value = '%s'",
octstr_get_cstr(gwlist_get(row,i))); */
}
gwlist_append(*res, row);
}
/* ignore OCI_NO_DATA error */
if (status != OCI_NO_DATA) {
List *row;
oracle_checkerr(conn->errhp, status);
for (i = 0; i < columns; i++)
gw_free(data[i].data);
gw_free(data);
while ((row = gwlist_extract_first(*res)) != NULL)
gwlist_destroy(row, octstr_destroy_item);
gwlist_destroy(*res, NULL);
*res = NULL;
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return -1;
}
for (i = 0; i < columns; i++)
gw_free(data[i].data);
gw_free(data);
OCIHandleFree(stmt, OCI_HTYPE_STMT);
return 0;
}
/******************************************************************************
* *
* Function: zbx_db_vselect *
* *
* Purpose: execute a select statement *
* *
* Return value: data, NULL (on error) or (DB_RESULT)ZBX_DB_DOWN *
* *
******************************************************************************/
DB_RESULT zbx_db_vselect(const char *fmt, va_list args)
{
char *sql = NULL;
DB_RESULT result = NULL;
double sec = 0;
#if defined(HAVE_IBM_DB2)
int i;
SQLRETURN ret = SQL_SUCCESS;
#elif defined(HAVE_ORACLE)
sword err = OCI_SUCCESS;
ub4 counter;
#elif defined(HAVE_POSTGRESQL)
char *error = NULL;
#elif defined(HAVE_SQLITE3)
int ret = FAIL;
char *error = NULL;
#endif
if (0 != CONFIG_LOG_SLOW_QUERIES)
sec = zbx_time();
sql = zbx_dvsprintf(sql, fmt, args);
if (1 == txn_error)
{
zabbix_log(LOG_LEVEL_DEBUG, "ignoring query [txnlev:%d] [%s] within failed transaction", txn_level, sql);
goto clean;
}
zabbix_log(LOG_LEVEL_DEBUG, "query [txnlev:%d] [%s]", txn_level, sql);
#if defined(HAVE_IBM_DB2)
result = zbx_malloc(result, sizeof(ZBX_IBM_DB2_RESULT));
memset(result, 0, sizeof(ZBX_IBM_DB2_RESULT));
/* allocate a statement handle */
if (SUCCEED != zbx_ibm_db2_success(ret = SQLAllocHandle(SQL_HANDLE_STMT, ibm_db2.hdbc, &result->hstmt)))
goto error;
/* directly execute the statement */
if (SUCCEED != zbx_ibm_db2_success(ret = SQLExecDirect(result->hstmt, (SQLCHAR *)sql, SQL_NTS)))
goto error;
/* identify the number of output columns */
if (SUCCEED != zbx_ibm_db2_success(ret = SQLNumResultCols(result->hstmt, &result->ncolumn)))
goto error;
if (0 == result->ncolumn)
goto error;
result->nalloc = 0;
result->values = zbx_malloc(result->values, sizeof(char *) * result->ncolumn);
result->values_cli = zbx_malloc(result->values_cli, sizeof(char *) * result->ncolumn);
result->values_len = zbx_malloc(result->values_len, sizeof(SQLINTEGER) * result->ncolumn);
for (i = 0; i < result->ncolumn; i++)
{
/* get the display size for a column */
if (SUCCEED != zbx_ibm_db2_success(ret = SQLColAttribute(result->hstmt, (SQLSMALLINT)(i + 1),
SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, &result->values_len[i])))
{
goto error;
}
result->values_len[i] += 1; /* '\0'; */
/* allocate memory to bind a column */
result->values_cli[i] = zbx_malloc(NULL, result->values_len[i]);
result->nalloc++;
/* bind columns to program variables, converting all types to CHAR */
if (SUCCEED != zbx_ibm_db2_success(ret = SQLBindCol(result->hstmt, (SQLSMALLINT)(i + 1),
SQL_C_CHAR, result->values_cli[i], result->values_len[i], &result->values_len[i])))
{
goto error;
}
}
error:
if (SUCCEED != zbx_ibm_db2_success(ret) || 0 == result->ncolumn)
{
zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);
zbx_ibm_db2_log_errors(SQL_HANDLE_STMT, result->hstmt);
IBM_DB2free_result(result);
result = (SQL_CD_TRUE == IBM_DB2server_status() ? NULL : (DB_RESULT)ZBX_DB_DOWN);
}
#elif defined(HAVE_MYSQL)
if (NULL == conn)
{
zabbix_errlog(ERR_Z3003);
result = NULL;
}
else
{
if (0 != mysql_query(conn, sql))
{
zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);
switch (mysql_errno(conn))
{
case CR_CONN_HOST_ERROR:
case CR_SERVER_GONE_ERROR:
case CR_CONNECTION_ERROR:
case CR_SERVER_LOST:
case ER_SERVER_SHUTDOWN:
case ER_ACCESS_DENIED_ERROR: /* wrong user or password */
case ER_ILLEGAL_GRANT_FOR_TABLE: /* user without any privileges */
case ER_TABLEACCESS_DENIED_ERROR:/* user without some privilege */
case ER_UNKNOWN_ERROR:
result = (DB_RESULT)ZBX_DB_DOWN;
break;
default:
result = NULL;
break;
}
}
else
result = mysql_store_result(conn);
}
#elif defined(HAVE_ORACLE)
result = zbx_malloc(NULL, sizeof(ZBX_OCI_DB_RESULT));
memset(result, 0, sizeof(ZBX_OCI_DB_RESULT));
err = OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&result->stmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);
if (OCI_SUCCESS == err)
{
err = OCIStmtPrepare(result->stmthp, oracle.errhp, (text *)sql, (ub4)strlen((char *)sql),
(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
}
if (OCI_SUCCESS == err)
{
err = OCIStmtExecute(oracle.svchp, result->stmthp, oracle.errhp, (ub4)0, (ub4)0,
(CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_COMMIT_ON_SUCCESS);
}
if (OCI_SUCCESS == err)
{
/* get the number of columns in the query */
err = OCIAttrGet((void *)result->stmthp, OCI_HTYPE_STMT, (void *)&result->ncolumn,
(ub4 *)0, OCI_ATTR_PARAM_COUNT, oracle.errhp);
}
if (OCI_SUCCESS != err)
goto error;
assert(0 < result->ncolumn);
result->values = zbx_malloc(NULL, result->ncolumn * sizeof(char *));
memset(result->values, 0, result->ncolumn * sizeof(char *));
for (counter = 1; OCI_SUCCESS == err && counter <= result->ncolumn; counter++)
{
OCIParam *parmdp = NULL;
OCIDefine *defnp = NULL;
ub4 char_semantics;
ub2 col_width;
/* request a parameter descriptor in the select-list */
err = OCIParamGet((void *)result->stmthp, OCI_HTYPE_STMT, oracle.errhp, (void **)&parmdp, (ub4)counter);
if (OCI_SUCCESS == err)
{
/* retrieve the length semantics for the column */
char_semantics = 0;
err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&char_semantics, (ub4 *)0,
(ub4)OCI_ATTR_CHAR_USED, (OCIError *)oracle.errhp);
}
if (OCI_SUCCESS == err)
{
col_width = 0;
if (char_semantics)
{
/* retrieve the column width in characters */
err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&col_width, (ub4 *)0,
(ub4)OCI_ATTR_CHAR_SIZE, (OCIError *)oracle.errhp);
}
else
{
/* retrieve the column width in bytes */
err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&col_width, (ub4 *)0,
(ub4)OCI_ATTR_DATA_SIZE, (OCIError *)oracle.errhp);
}
}
col_width++;
result->values[counter - 1] = zbx_malloc(NULL, col_width);
memset(result->values[counter - 1], 0, col_width);
if (OCI_SUCCESS == err)
{
/* represent any data as characters */
err = OCIDefineByPos(result->stmthp, &defnp, oracle.errhp, counter,
(dvoid *)result->values[counter - 1], col_width, SQLT_STR,
(dvoid *)0, (ub2 *)0, (ub2 *)0, OCI_DEFAULT);
}
/* free cell descriptor */
OCIDescriptorFree(parmdp, OCI_DTYPE_PARAM);
parmdp = NULL;
}
error:
if (OCI_SUCCESS != err)
{
zabbix_errlog(ERR_Z3005, err, zbx_oci_error(err), sql);
OCI_DBfree_result(result);
result = (OCI_SERVER_NORMAL == OCI_DBserver_status() ? NULL : (DB_RESULT)ZBX_DB_DOWN);
}
#elif defined(HAVE_POSTGRESQL)
result = zbx_malloc(NULL, sizeof(ZBX_PG_DB_RESULT));
result->pg_result = PQexec(conn, sql);
result->values = NULL;
result->cursor = 0;
result->row_num = 0;
if (NULL == result->pg_result)
zabbix_errlog(ERR_Z3005, 0, "result is NULL", sql);
if (PGRES_TUPLES_OK != PQresultStatus(result->pg_result))
{
error = zbx_dsprintf(error, "%s:%s",
PQresStatus(PQresultStatus(result->pg_result)),
PQresultErrorMessage(result->pg_result));
zabbix_errlog(ERR_Z3005, 0, error, sql);
zbx_free(error);
PG_DBfree_result(result);
result = (CONNECTION_OK == PQstatus(conn) ? NULL : (DB_RESULT)ZBX_DB_DOWN);
}
else /* init rownum */
result->row_num = PQntuples(result->pg_result);
#elif defined(HAVE_SQLITE3)
if (0 == txn_level && PHP_MUTEX_OK != php_sem_acquire(&sqlite_access))
{
zabbix_log(LOG_LEVEL_CRIT, "ERROR: cannot create lock on SQLite3 database");
exit(FAIL);
}
result = zbx_malloc(NULL, sizeof(ZBX_SQ_DB_RESULT));
result->curow = 0;
lbl_get_table:
if (SQLITE_OK != (ret = sqlite3_get_table(conn,sql, &result->data, &result->nrow, &result->ncolumn, &error)))
{
if (SQLITE_BUSY == ret)
goto lbl_get_table;
zabbix_errlog(ERR_Z3005, 0, error, sql);
sqlite3_free(error);
SQ_DBfree_result(result);
switch (ret)
{
case SQLITE_ERROR: /* SQL error or missing database; assuming SQL error, because if we
are this far into execution, zbx_db_connect() was successful */
case SQLITE_NOMEM: /* a malloc() failed */
case SQLITE_MISMATCH: /* data type mismatch */
result = NULL;
break;
default:
result = (DB_RESULT)ZBX_DB_DOWN;
break;
}
}
if (0 == txn_level)
php_sem_release(&sqlite_access);
#endif /* HAVE_SQLITE3 */
if (0 != CONFIG_LOG_SLOW_QUERIES)
{
sec = zbx_time() - sec;
if (sec > (double)CONFIG_LOG_SLOW_QUERIES / 1000.0)
zabbix_log(LOG_LEVEL_WARNING, "slow query: " ZBX_FS_DBL " sec, \"%s\"", sec, sql);
}
if (NULL == result && 0 < txn_level)
{
zabbix_log(LOG_LEVEL_DEBUG, "query [%s] failed, setting transaction as failed", sql);
txn_error = 1;
}
clean:
zbx_free(sql);
return result;
}
/*************************************************************************
*
* Function: sql_select_query
*
* Purpose: Issue a select query to the database
*
*************************************************************************/
static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
int x;
int y;
int colcount;
OCIParam *param;
OCIDefine *define;
ub2 dtype;
ub2 dsize;
char **rowdata=NULL;
sb2 *indicators;
rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
if (config->sqltrace)
DEBUG(querystr);
if (oracle_sock->conn == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
return SQL_DOWN;
}
if (OCIStmtPrepare (oracle_sock->queryHandle, oracle_sock->errHandle,
querystr, strlen(querystr),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_select_query: %s",sql_error(sqlsocket, config));
return -1;
}
/* Query only one row by default (for now) */
x = OCIStmtExecute(oracle_sock->conn,
oracle_sock->queryHandle,
oracle_sock->errHandle,
(ub4) 0,
(ub4) 0,
(OCISnapshot *) NULL,
(OCISnapshot *) NULL,
(ub4) OCI_DEFAULT);
if (x == OCI_NO_DATA) {
/* Nothing to fetch */
return 0;
}
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: query failed in sql_select_query: %s",
sql_error(sqlsocket, config));
return sql_check_error(sqlsocket, config);
}
/*
* Define where the output from fetch calls will go
*
* This is a gross hack, but it works - we convert
* all data to strings for ease of use. Fortunately, most
* of the data we deal with is already in string format.
*/
colcount = sql_num_fields(sqlsocket, config);
/* DEBUG2("sql_select_query(): colcount=%d",colcount); */
/*
* FIXME: These malloc's can probably go, as the schema
* is fixed...
*/
rowdata=(char **)rad_malloc(sizeof(char *) * (colcount+1) );
memset(rowdata, 0, (sizeof(char *) * (colcount+1) ));
indicators = (sb2 *) rad_malloc(sizeof(sb2) * (colcount+1) );
memset(indicators, 0, sizeof(sb2) * (colcount+1));
for (y=1; y <= colcount; y++) {
x=OCIParamGet(oracle_sock->queryHandle, OCI_HTYPE_STMT,
oracle_sock->errHandle,
(dvoid **)¶m,
(ub4) y);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIParamGet() failed in sql_select_query: %s",
sql_error(sqlsocket, config));
return -1;
}
x=OCIAttrGet((dvoid*)param, OCI_DTYPE_PARAM,
(dvoid*)&dtype, (ub4*)0, OCI_ATTR_DATA_TYPE,
oracle_sock->errHandle);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIAttrGet() failed in sql_select_query: %s",
sql_error(sqlsocket, config));
return -1;
}
dsize=MAX_DATASTR_LEN;
/*
* Use the retrieved length of dname to allocate an output
* buffer, and then define the output variable (but only
* for char/string type columns).
*/
switch(dtype) {
#ifdef SQLT_AFC
case SQLT_AFC: /* ansii fixed char */
#endif
#ifdef SQLT_AFV
case SQLT_AFV: /* ansii var char */
#endif
case SQLT_VCS: /* var char */
case SQLT_CHR: /* char */
case SQLT_STR: /* string */
x=OCIAttrGet((dvoid*)param, (ub4) OCI_DTYPE_PARAM,
(dvoid*) &dsize, (ub4 *)0, (ub4) OCI_ATTR_DATA_SIZE,
oracle_sock->errHandle);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIAttrGet() failed in sql_select_query: %s",
sql_error(sqlsocket, config));
return -1;
}
rowdata[y-1]=rad_malloc(dsize+1);
memset(rowdata[y-1], 0, dsize+1);
break;
case SQLT_DAT:
case SQLT_INT:
case SQLT_UIN:
case SQLT_FLT:
case SQLT_PDN:
case SQLT_BIN:
case SQLT_NUM:
rowdata[y-1]=rad_malloc(dsize+1);
memset(rowdata[y-1], 0, dsize+1);
break;
default:
dsize=0;
rowdata[y-1]=NULL;
break;
}
indicators[y-1] = 0;
x=OCIDefineByPos(oracle_sock->queryHandle,
&define,
oracle_sock->errHandle,
y,
(ub1 *) rowdata[y-1],
dsize+1,
SQLT_STR,
&indicators[y-1],
(dvoid *) 0,
(dvoid *) 0,
OCI_DEFAULT);
/*
* FIXME: memory leaks of indicators & rowdata?
*/
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIDefineByPos() failed in sql_select_query: %s",
sql_error(sqlsocket, config));
return -1;
}
}
oracle_sock->results=rowdata;
oracle_sock->indicators=indicators;
return 0;
}
/*
* Send an SQL query to the server
*/
static int db_oracle_submit_query(const db1_con_t* _h, const str* _s)
{
OCIBind* bind[MAX_BIND_HANDLES];
OCIDate odt[sizeof(bind)/sizeof(bind[0])];
str tmps;
sword status;
int pass;
ora_con_t* con = CON_ORA(_h);
query_data_t* pqd = con->pqdata;
size_t hc = pqd->_n + pqd->_nw;
OCIStmt *stmthp;
if (hc >= sizeof(bind)/sizeof(bind[0])) {
LM_ERR("too many bound. Rebuild with MAX_BIND_HANDLES >= %u\n",
(unsigned)hc);
return -1;
}
if (!pqd->_rs) {
/*
* This method is at ~25% faster as set OCI_COMMIT_ON_SUCCESS
* in StmtExecute
*/
tmps.len = snprintf(st_buf, sizeof(st_buf),
"begin %.*s; commit write batch nowait; end;",
_s->len, _s->s);
if ((unsigned)tmps.len >= sizeof(st_buf))
return sql_buf_small();
tmps.s = st_buf;
_s = &tmps;
}
pass = 1;
if (!con->connected) {
status = db_oracle_reconnect(con);
if (status != OCI_SUCCESS) {
LM_ERR("can't restore connection: %s\n", db_oracle_error(con, status));
return -2;
}
LM_INFO("connection restored\n");
--pass;
}
repeat:
stmthp = NULL;
status = OCIHandleAlloc(con->envhp, (dvoid**)(dvoid*)&stmthp,
OCI_HTYPE_STMT, 0, NULL);
if (status != OCI_SUCCESS)
goto ora_err;
status = OCIStmtPrepare(stmthp, con->errhp, (text*)_s->s, _s->len,
OCI_NTV_SYNTAX, OCI_DEFAULT);
if (status != OCI_SUCCESS)
goto ora_err;
if (hc) {
bmap_t bmap;
size_t pos = 1;
int i;
memset(bind, 0, hc*sizeof(bind[0]));
for (i = 0; i < pqd->_n; i++) {
if (db_oracle_val2bind(&bmap, &pqd->_v[i], &odt[pos]) < 0)
goto bind_err;
status = OCIBindByPos(stmthp, &bind[pos], con->errhp,
pos, bmap.addr, bmap.size, bmap.type,
NULL, NULL, NULL, 0, NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS)
goto ora_err;
++pos;
}
for (i = 0; i < pqd->_nw; i++) {
if (db_oracle_val2bind(&bmap, &pqd->_w[i], &odt[pos]) < 0) {
bind_err:
OCIHandleFree(stmthp, OCI_HTYPE_STMT);
LM_ERR("can't map values\n");
return -3;
}
status = OCIBindByPos(stmthp, &bind[pos], con->errhp,
pos, bmap.addr, bmap.size, bmap.type,
NULL, NULL, NULL, 0, NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS)
goto ora_err;
++pos;
}
}
// timelimited operation
status = begin_timelimit(con, 0);
if (status != OCI_SUCCESS) goto ora_err;
do status = OCIStmtExecute(con->svchp, stmthp, con->errhp,
!pqd->_rs, 0, NULL, NULL,
pqd->_rs ? OCI_STMT_SCROLLABLE_READONLY : OCI_DEFAULT);
while (wait_timelimit(con, status));
if (done_timelimit(con, status)) goto stop_exec;
switch (status) {
case OCI_SUCCESS_WITH_INFO:
LM_WARN("driver: %s\n", db_oracle_errorinfo(con));
//PASS THRU
case OCI_SUCCESS:
if (pqd->_rs)
*pqd->_rs = stmthp;
else
OCIHandleFree(stmthp, OCI_HTYPE_STMT);
return 0;
default:
pass = -pass;
break;
}
ora_err:
LM_ERR("driver: %s\n", db_oracle_error(con, status));
stop_exec:
if (stmthp)
OCIHandleFree(stmthp, OCI_HTYPE_STMT);
if (pass == -1 && !con->connected) {
/* Attemtp to reconnect */
if (db_oracle_reconnect(con) == OCI_SUCCESS) {
LM_NOTICE("attempt repeat after reconnect\n");
pass = 0;
goto repeat;
}
LM_ERR("connection loss\n");
}
return -4;
}
static sword zbx_oracle_statement_prepare(const char *sql)
{
return OCIStmtPrepare(oracle.stmthp, oracle.errhp, (text *)sql, (ub4)strlen((char *)sql), (ub4)OCI_NTV_SYNTAX,
(ub4)OCI_DEFAULT);
}
