Esempio n. 1
0
void  Oracle8Query::rollback(const XID& xid)
{
  Oracle8QueryEndTransactionGuard endTransactionGuard(*this,xid);
  OCITransSet::TransRecord* tr;
  OCITransSet::State state;
  try {
    tr = OCITransSet::attach(*handles_p_,xid,0,false);
  }catch(const OCIException& ex){
    fillDBError();
    throw CosTransactions::HeuristicHazard();
  }
  {
   GradSoft::ReadLocker rl(tr->rwlock);
   state = tr->state;
  }
  if (state==OCITransSet::commited)
    throw CosTransactions::HeuristicCommit();
  if (state==OCITransSet::commited_with_error)
    throw CosTransactions::HeuristicHazard();
  if (state==OCITransSet::rollbacked)
    return;
  if (state==OCITransSet::forgotted)
    return;
  OCISvcCtx* ociSvcCtx_p =  handles_p_->getSvcCtx_p();
  sword res = OCITransRollback(ociSvcCtx_p,ociError_p(),OCI_DEFAULT);
  if (res!=OCI_SUCCESS) {
    fillDBError();
  }
  state=OCITransSet::rollbacked;
  { 
   GradSoft::WriteLocker wl(tr->rwlock); 
   tr->state = state;
  }
}
Esempio n. 2
0
static VALUE complex_logoff_execute(void *arg)
{
    complex_logoff_arg_t *cla = (complex_logoff_arg_t *)arg;
    OCIError *errhp = oci8_errhp;
    sword rv = OCI_SUCCESS;

    OCITransRollback(cla->svchp, errhp, OCI_DEFAULT);

    if (cla->state & OCI8_STATE_SESSION_BEGIN_WAS_CALLED) {
        rv = OCISessionEnd(cla->svchp, oci8_errhp, cla->usrhp, OCI_DEFAULT);
        cla->state &= ~OCI8_STATE_SESSION_BEGIN_WAS_CALLED;
    }
    if (cla->state & OCI8_STATE_SERVER_ATTACH_WAS_CALLED) {
        rv = OCIServerDetach(cla->srvhp, oci8_errhp, OCI_DEFAULT);
        cla->state &= ~OCI8_STATE_SERVER_ATTACH_WAS_CALLED;
    }
    if (cla->usrhp != NULL) {
        OCIHandleFree(cla->usrhp, OCI_HTYPE_SESSION);
    }
    if (cla->srvhp != NULL) {
        OCIHandleFree(cla->srvhp, OCI_HTYPE_SERVER);
    }
    if (cla->svchp != NULL) {
        OCIHandleFree(cla->svchp, OCI_HTYPE_SVCCTX);
    }
    free(cla);
    return (VALUE)rv;
}
Esempio n. 3
0
void
oracle_session_rollback (GSQLSession *session)
{
    GSQL_TRACE_FUNC;

    sword ret;
    gchar *mess;
    GSQLWorkspace *workspace;
    GSQLEOracleSession * o_session;

    o_session = (GSQLEOracleSession *) session->spec;

    workspace = gsql_session_get_workspace (session);

    ret = OCITransRollback(o_session->svchp, o_session->errhp, OCI_DEFAULT);

    if (ret != OCI_SUCCESS)
    {
        mess = oracle_get_error_string (o_session->errhp);
        gsql_message_add (workspace,
                          GSQL_MESSAGE_ERROR, mess);
        g_free (mess);
    } else
        gsql_message_add (workspace,
                          GSQL_MESSAGE_NOTICE, N_("Transaction rolled back"));

}
Esempio n. 4
0
int COracleDB::oracle_rollback( void )
{
	ORACLE_HANDLE* handle = ( ORACLE_HANDLE* ) _handle;

	int status = 0;

	int errcode = 0;

	time_t t1 = time( NULL );

	while ( ( status = OCITransRollback( handle->svchp, handle->errhp, 0 ) ) == OCI_STILL_EXECUTING ) {
		if ( time( NULL ) - t1 > 60 ) {
			// timeout
			errcode = DB_ERR_TIMEOUT;
			break;
		}
		my_usleep();
	}

	if ( errcode != DB_ERR_TIMEOUT && status ) {
		errcode = checkerr( handle->errhp, status, _errinfo );

		if ( errcode == 1012 || errcode == 12705 || errcode == 3113 || errcode == 3114 || errcode == 12541
				|| errcode == 12547 ) {
			errcode = DB_ERR_NOCONNECTION;
		} else {
			errcode = DB_ERR_FAILED;
		}
	}

	return errcode;
}
Esempio n. 5
0
static int yada_oracle_rollback(yada_t *_yada, int flags)
{
  char errbuf[1024];
  sb4 errcode;


  /* check database connection */
  if(!_yada->_mod->env)
    {
    _yada_set_err(_yada, 0, "database unavailable");
    return(-1);
    }

  if(OCITransRollback(_yada->_mod->ctx, _yada->_mod->err, OCI_DEFAULT)
    != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    _yada->disconnect(_yada);
    return(-1);
    }

  if(_yada->_mod->flags & ORAF_INTRX)
    _yada->_mod->flags ^= ORAF_INTRX;
  return(0);
}
Esempio n. 6
0
void DataBase::_DB_EndTrans(int flag)
{
	if(0 == flag)        
		OCITransCommit(DBSession->svchp, DBSession->errhp, (ub4) 0);
	else
		OCITransRollback(DBSession->svchp, DBSession->errhp, (ub4) 0);

	return;
}
Esempio n. 7
0
/*
** Rollback the current transaction.
*/
static int conn_rollback (lua_State *L) {
	conn_data *conn = getconnection (L);
	ASSERT (L, OCITransRollback (conn->svchp, conn->errhp, OCI_DEFAULT),
		conn->errhp);
/*
	if (conn->auto_commit == 0) 
		sql_begin(conn); 
*/
	return 0;
}
Esempio n. 8
0
static VALUE simple_logoff_execute(void *arg)
{
    simple_logoff_arg_t *sla = (simple_logoff_arg_t *)arg;
    OCIError *errhp = oci8_errhp;
    sword rv;

    OCITransRollback(sla->svchp, errhp, OCI_DEFAULT);
    rv = OCILogoff(sla->svchp, errhp);
    free(sla);
    return (VALUE)rv;
}
Esempio n. 9
0
/*
** Set "auto commit" property of the connection.
** If 'true', then rollback current transaction.
** If 'false', then start a new transaction.
*/
static int conn_setautocommit (lua_State *L) {
	conn_data *conn = getconnection (L);
	if (lua_toboolean (L, 2)) {
		conn->auto_commit = 1;
		/* Undo active transaction. */
		ASSERT (L, OCITransRollback (conn->svchp, conn->errhp,
			OCI_DEFAULT), conn->errhp);
	}
	else {
		conn->auto_commit = 0;
		/* sql_begin(conn);*/
	}
	lua_pushboolean(L, 1);
	return 1;
}
Esempio n. 10
0
/*
=begin

--- OCISvcCtx#rollback([flags])
     rollback the transaction.

     :flags
        ((|OCI_DEFAULT|)) only valid. Default value is ((|OCI_DEFAULT|)).

     correspond native OCI function: ((|OCITransRollback|))
=end
*/
static VALUE oci8_trans_rollback(int argc, VALUE *argv, VALUE self)
{
  VALUE vflags;
  oci8_handle_t *h;
  ub4 flags;
  sword rv;

  rb_scan_args(argc, argv, "01", &vflags);
  Get_Handle(self, h); /* 0 */
  Get_Int_With_Default(argc, 1, vflags, flags, OCI_DEFAULT); /* 1 */

  rv = OCITransRollback(h->hp, h->errhp, flags);
  if (rv != OCI_SUCCESS) {
    oci8_raise(h->errhp, rv, NULL);
  }
  return self;
}
Esempio n. 11
0
/******************************************************************************
 *                                                                            *
 * Function: zbx_db_rollback                                                  *
 *                                                                            *
 * Purpose: rollback transaction                                              *
 *                                                                            *
 * Author: Eugene Grigorjev                                                   *
 *                                                                            *
 * Comments: do nothing if DB does not support transactions                   *
 *                                                                            *
 ******************************************************************************/
int	zbx_db_rollback()
{
	int	rc = ZBX_DB_OK, last_txn_error;

	if (0 == txn_level)
	{
		zabbix_log(LOG_LEVEL_CRIT, "ERROR: rollback without transaction."
				" Please report it to Job Arranger Team.");
		assert(0);
	}

	last_txn_error = txn_error;

	/* allow rollback of failed transaction */
	txn_error = 0;

#if defined(HAVE_IBM_DB2)
	if (SUCCEED != zbx_ibm_db2_success(SQLEndTran(SQL_HANDLE_DBC, ibm_db2.hdbc, SQL_ROLLBACK)))
		rc = ZBX_DB_DOWN;
	if (SUCCEED != zbx_ibm_db2_success(SQLSetConnectAttr(ibm_db2.hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS)))
		rc = ZBX_DB_DOWN;

	if (ZBX_DB_OK != rc)
	{
		zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);
		rc = (SQL_CD_TRUE == IBM_DB2server_status() ? ZBX_DB_FAIL : ZBX_DB_DOWN);
	}
#elif defined(HAVE_MYSQL) || defined(HAVE_POSTGRESQL)
	rc = zbx_db_execute("%s", "rollback;");
#elif defined(HAVE_ORACLE)
	OCITransRollback(oracle.svchp, oracle.errhp, OCI_DEFAULT);
#elif defined(HAVE_SQLITE3)
	rc = zbx_db_execute("%s", "rollback;");
	php_sem_release(&sqlite_access);
#endif

	if (ZBX_DB_DOWN != rc)	/* ZBX_DB_FAIL or ZBX_DB_OK or number of changes */
		txn_level--;
	else
		txn_error = last_txn_error;	/* in case of DB down we will repeat this operation */

	return rc;
}
Esempio n. 12
0
/*
  Execute a SQL command which has no resulting table.  Examples include
  insert, delete, update.
*/
int
cllExecSqlNoResult( icatSessionStruct *icss, const char *sqlInput ) {

    int stat, stat2, stat3;
    OCIEnv           *p_env;
    OCISvcCtx        *p_svc;
    static OCIStmt          *p_statement;
    char sql[MAX_SQL_SIZE];
    ub4 rows_affected;
    ub4 *pUb4;

    stat = convertSqlToOra( ( char* )sqlInput, sql );
    if ( stat != 0 ) {
        rodsLog( LOG_ERROR, "cllExecSqlNoResult: SQL too long" );
        return CAT_OCI_ERROR;
    }

    p_svc = ( OCISvcCtx * )icss->connectPtr;
    p_env = ( OCIEnv * )icss->environPtr;

    if ( strcmp( sql, "commit" ) == 0 ) {
        rodsLogSql( sql );
        stat = OCITransCommit( p_svc, p_err, ( ub4 ) OCI_DEFAULT );
        stat2 = logExecuteStatus( stat, sql, "cllExecSqlNoResult" );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCITransCommit failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }
        return 0;
    }

    if ( strcmp( sql, "rollback" ) == 0 ) {
        rodsLogSql( sql );
        stat = OCITransRollback( p_svc, p_err, ( ub4 ) OCI_DEFAULT );
        stat2 = logExecuteStatus( stat, sql, "cllExecSqlNoResult" );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCITransRollback failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }
        return 0;
    }


    /* Allocate SQL statement */
    stat = OCIHandleAlloc( ( dvoid * ) p_env, ( dvoid ** ) &p_statement,
                           OCI_HTYPE_STMT, ( size_t ) 0, ( dvoid ** ) 0 );
    if ( stat != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCIHandleAlloc failed: %d", stat );
        logOraError( LOG_ERROR, p_err, stat );
        return CAT_OCI_ERROR;
    }

    /* Prepare SQL statement */
    stat = OCIStmtPrepare( p_statement, p_err, ( OraText * )sql,
                           ( ub4 ) strlen( sql ),
                           ( ub4 ) OCI_NTV_SYNTAX, ( ub4 ) OCI_DEFAULT );
    if ( stat != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCIStmtPrepare failed: %d", stat );
        rodsLog( LOG_ERROR, sql );
        logOraError( LOG_ERROR, p_err, stat );
        return CAT_OCI_ERROR;
    }

    if ( bindTheVariables( p_statement, sql ) != 0 ) {
        logTheBindVariables( LOG_ERROR );
        return CAT_OCI_ERROR;
    }
    logTheBindVariables( 0 );
    rodsLogSql( sql );

    /* Execute statement */
    stat = OCIStmtExecute( p_svc, p_statement, p_err, ( ub4 ) 1, ( ub4 ) 0,
                           ( CONST OCISnapshot * ) NULL, ( OCISnapshot * ) NULL,
                           OCI_DEFAULT );
    stat2 = logExecuteStatus( stat, sql, "cllExecSqlNoResult" );
    if ( stat == OCI_NO_DATA ) { /* Don't think this ever happens, but... */
        return CAT_SUCCESS_BUT_WITH_NO_INFO;
    }

    /* malloc it so that it's aligned properly, else can get
       bus errors when doing 64-bit addressing */
    pUb4 = ( ub4* ) malloc( sizeof( rows_affected ) );
    *pUb4 = 0;
    rows_affected = 0;

    if ( stat == OCI_ERROR ) {
        rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCIStmtExecute failed: %d", stat );
        logOraError( LOG_ERROR, p_err, stat );
        free( pUb4 );
        if ( stat2 == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME ) {
            return stat2;
        }
        return CAT_OCI_ERROR;
    }

    stat3 = OCIAttrGet( ( dvoid * )p_statement, OCI_HTYPE_STMT, pUb4, 0,
                        OCI_ATTR_ROW_COUNT, ( OCIError * ) p_err );
    rows_affected = *pUb4;
    free( pUb4 );

    stat = OCIHandleFree( ( dvoid * )p_statement, OCI_HTYPE_STMT ); /* free the
                                                                    statement */

    if ( stat3 != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllExecSqlNoResult: OCIAttrGet failed: %d", stat );
        return stat3;
    }
    /* rodsLog(LOG_NOTICE, "cllExecSqlNoResult: OCIAttrGet, rows_affected: %d",
       rows_affected); */
    if ( rows_affected == 0 ) {
        return CAT_SUCCESS_BUT_WITH_NO_INFO;
    }

    return stat2;

}
Esempio n. 13
0
void *thread_process() {
     int thisret,size,i,fields,j,bufout=0,counter=0;
	 int fetch_resu;
     long int datalen,buflen=0;
     int ociposi=-1;
     char buf[_buflen],tmp[_buflen],*realdata ;
     mytext *sqldata;
     int realdatalen=0;
     ub1   *bufp;
     int bufpint=1024;
     dvoid *hdlptr = (dvoid *) 0,*tmphdlptr = (dvoid *) 0;
     ub1   in_out = 0;
     sb2   indptr = 0;
     ub1   piece = OCI_FIRST_PIECE;
     ub4 	hdltype = OCI_HTYPE_DEFINE, iter = 0, idx = 0;
     int poid;
     pthread_detach(pthread_self());
     sqldata=(mytext *)malloc(sizeof(mytext));
     sqldata->next=0;
     sqldata->last=0;
     sqldata->size=0;
     bufp=(ub1 *)malloc(sizeof(ub1)*_clobmax);//**bufp must set to _clobmax
     
     realdata=(char *)malloc(_buflen);  
     realdatalen=_buflen;
     
     if((ociposi=getsession())==-1){
          printf("pool is busy!!\n");
          buf[16]=0;
          exit(1);
     }          
	 
	 
     poci[ociposi].threadid=pthread_self();    
     poci[ociposi].id=ociposi;
     printf("thread id=%d , ociposi=%d \n",pthread_self(),ociposi);
     memset(buf,0,_buflen);
     
			 
     while(1){
          pthread_mutex_lock(&mylock);
          thisret=accept(sock,NULL,NULL);
          pthread_mutex_unlock(&mylock);
          
          poci[ociposi].busy=1;
          bufout=0;
          conn_times++;
          if(conn_times>=1000000){conn_times1++;conn_times=0;}
          if(conn_times1>=1000000)conn_times1=0;
          printf("connections %d millions %d socket=%d ociposi=%d\n",conn_times1,conn_times,thisret,ociposi);
          
          poci[ociposi].datetime=datetime->tm_min*60+datetime->tm_sec;
          poci[ociposi].transfer=0;
          //data_buffer(sqldata,"",2,0);
	        while(sqldata->next){
	            sqldata=sqldata->next;
	        }
	        sqldata->size=0;
	        while(sqldata->last){
	            sqldata=sqldata->last;
	            sqldata->size=0;
	        }								   

          
          
          poci[ociposi].sock=thisret;
          
          
          
          while(size=recv(thisret,buf,_buflen,0)){
               buflen=size;
               buf[buflen]=0;
               poci[ociposi].transfer=1;
               //printf("--buflen=%d \n",buflen);
               
               if(buflen>2){
               }
               else{
                   bufout++;
                   if(bufout>=5 || buflen<=0)break;
               }
               size=buflen;
               if(poci[ociposi].sock==0)continue;
               poci[ociposi].datetime=datetime->tm_min*60+datetime->tm_sec;
               
               
               data_buffer(sqldata,buf,1,buflen);               
               
               //end
               j=0;
               if(size>9)
               for(i=size-9;i<size;i++){
                   tmp[j]=buf[i];
                   j++;
               }
               tmp[j]=0;          
               if((strncmp(buf,_end,strlen(_end))==0)||(strncmp(tmp,_end,strlen(_end))==0)){
                   break;
               }
          
               //set commit off
               if(strncmp(buf,_commitoff,strlen(_commitoff))==0){
                   poci[ociposi].commitmode=1;
                   memset(buf,0,sizeof(buf));
                   send(thisret,_autocommitoff,strlen(_autocommitoff),0);
                   continue;
               }
          
               //_commit
               if(strncmp(buf,_commit,strlen(_commit))==0){
                   OCITransCommit(poci[ociposi].svchp,poci[ociposi].errhp,OCI_DEFAULT );
                   memset(buf,0,sizeof(buf));
                   continue;
               }
                          
               //set commit on
               if(strncmp(buf,_commiton,strlen(_commiton))==0){              
                   poci[ociposi].commitmode=0;
                   memset(buf,0,sizeof(buf));
                   send(thisret,_autocommiton,strlen(_autocommiton),0);
                   continue;
               }                                                                              
               
               //rollback
               if(strncmp(buf,_rollback,strlen(_rollback))==0){
                   OCITransRollback(poci[ociposi].svchp,poci[ociposi].errhp,OCI_DEFAULT) ;
                   poci[ociposi].commitmode=1;
                   memset(buf,0,sizeof(buf));
                   continue;   
               }
               //_serverdown
               if(strncmp(buf,_serverdown,strlen(_serverdown))==0){
               	   OCITerminate(OCI_DEFAULT);
                   exit(1);
               }                    
          
          
               if(sqldata->size+1>=_mytextlen)
               while(sqldata->next){
                  if(sqldata->size+1>=_mytextlen)
                     sqldata=sqldata->next;
                  else
                     break;
               }
               //end input
               size=sqldata->size;
               datalen=size-2; 
               j=0;
               if(size>15)
               for(i=size-15;i<size;i++){
                   tmp[j]=sqldata->mydata[i];
                   j++;
               }
               tmp[j]=0;
               if((strncmp(tmp,_inputend,strlen(_inputend))==0)){    
                   datalen=data_buffer(sqldata,buf,3,0);
                   if(datalen+1>realdatalen){
                       printf("free\n");
                       free(realdata);
                       printf("malloc\n");
                       realdata=(char *)malloc(datalen+1); 
                       realdatalen=datalen+1;
                   }
                   data_buffer(sqldata,realdata,4,0);
                   
                   size=realdatalen;
                   realdata[size-17]=0;          
                   
				   
                   OCIHandleAlloc(poci[ociposi].envhp,(dvoid*)&poci[ociposi].stmthp,OCI_HTYPE_STMT,0,0);
				   
				   printf("oracle_query \n");
                   fields=oracle_query(&poci[ociposi],realdata,datalen-17,tmp);
				   printf("oracle_query ok fields=%d \n",fields);
				   
				   if(fields<=0)break;
                   //printf("start fetch\n");
                   i=0;
				   counter=0;
                   if(fields>0){
                       piece = OCI_FIRST_PIECE ;
                       bufp[0]=0;
                       fetch_data(&poci[ociposi]);
					   counter++;printf("counter=%d \n",counter);
                       send_process(_output_begin,strlen(_output_begin),&poci[ociposi]);
                       
                       while (poci[ociposi].status != OCI_NO_DATA){
               	           //if(OCI_NEED_DATA==poci[ociposi].status){
	               	           //bufpint=4096;
	                           //poci[ociposi].status = OCIStmtGetPieceInfo(poci[ociposi].stmthp, poci[ociposi].errhp, &hdlptr, &hdltype,&in_out, &iter, &idx, &piece);
	                           //poci[ociposi].status = OCIStmtSetPieceInfo(hdlptr, hdltype, poci[ociposi].errhp,(dvoid *) bufp, &bufpint, piece,(CONST dvoid *) &indptr, (ub2 *) 0);
							   
						   //}
						   
						   //printf("data=%s\n",poci[ociposi].data[0]);
						   //printf("data=%s\n",poci[ociposi].data[1]);
						   //printf("data=%s\n",poci[ociposi].data[2]);
						   
						   fetch_data(&poci[ociposi]);
						   if(poci[ociposi].status<0)break;
						   
						   counter++;printf("OCI_NO_DATA=%d , poci[ociposi].status=%d , counter=%d fetch_resu=%d \n",OCI_NO_DATA,poci[ociposi].status,counter);
						   bufp[bufpint]=0;
						   
						   
							for (i=0;i<fields;i++){
								send_process(poci[ociposi].data[i],strlen(poci[ociposi].data[i]),&poci[ociposi]);
								if(i+1<fields){
									send_process(_output_column,strlen(_output_column),&poci[ociposi]);
								}
							}
						    send_process(_output_row,strlen(_output_row),&poci[ociposi]);
						   /*
						   if(poci[ociposi].status==OCI_NEED_DATA){
								if(tmphdlptr!=hdlptr){
								  i++;
							  if(i>1)
							  if((i-1)%fields==0){
								  send_process(_output_row,strlen(_output_row),&poci[ociposi]);
							   }else{
								  send_process(_output_column,strlen(_output_column),&poci[ociposi]);
							   }
							   tmphdlptr=hdlptr;
							   }
							   send_process(bufp,bufpint,&poci[ociposi]);
						   }*/
                       	}
                       	
                       	if(i>1){
                       		send_process(_output_column,strlen(_output_column),&poci[ociposi]);
                       		send_process(bufp,bufpint,&poci[ociposi]);
                       		send_process(_output_row,strlen(_output_row),&poci[ociposi]);
                       	}
                       	send_process(_output_end,strlen(_output_end),&poci[ociposi]);
                   }else{
                      if((fields<0) && (strlen(poci[ociposi].errbuf)>0)){
                      	   send_process(_output_beginerr,strlen(_output_beginerr),&poci[ociposi]);
                           send_process(poci[ociposi].errbuf,512,&poci[ociposi]);
                           send_process(_output_end,strlen(_output_end),&poci[ociposi]);
                      }else{
                           send_process(_ok,strlen(_ok),&poci[ociposi]);
                      }
                   }
                   
                   OCIHandleFree(poci[ociposi].stmthp,OCI_HTYPE_STMT);
                   //printf("fetch ok\n");                                                         
                   send_process("",-1,&poci[ociposi]);
								   //printf("data send ok\n");
						       datalen=0;
								   //data_buffer(sqldata,"",2,0);
						        while(sqldata->next){
						            sqldata=sqldata->next;
						        }
						        sqldata->size=0;
						        while(sqldata->last){
						            sqldata=sqldata->last;
						            sqldata->size=0;
						        }								   
								   //printf("query complete\n");
		               
               }
               poci[ociposi].transfer=0;
          }
          close(thisret);
          poci[ociposi].busy=0;
		  if(fields==-99){
			poci[ociposi].id=-1;
			OCILogoff(poci[ociposi].svchp,poci[ociposi].errhp);
			OCIHandleFree(poci[ociposi].envhp,OCI_HTYPE_ENV);
			
			pthread_create(&ph[ociposi], NULL, &thread_process,NULL);
			printf("exit program \n");
			break;
		  
		  }
    }   

}
Esempio n. 14
0
int  OracleConnection_rollback(T C) {
        assert(C);
        C->lastError = OCITransRollback(C->svc, C->err, OCI_DEFAULT);
        return C->lastError == OCI_SUCCESS;
}
Esempio n. 15
0
// Это просто роллбак...
int ora_rollback(database *db) {
t_ora *o = db->h;
if (!o) return ora_error(db);
if (!ora_ok(OCITransRollback(o->svchp,o->errhp, 0))) return ora_error(db);
return 1;
}
Esempio n. 16
0
JP_INTERNAL(int) JP_Rollback(TJConnector &conn)
{
  conn.result = OCITransRollback(conn.ociSvcCtx, conn.ociError,
                                    OCI_DEFAULT);
  return _Result(conn);
}
Esempio n. 17
0
/*
 * Add a new message to the database.
 *  session    - session name
 *  sender_uid -
 *  rcpts      -
 *  content    -
 *  recv_time  - time of arrival
 *  quiet      - print error messages?
 * Returns 0 on success
 */
int oralog_db_new_msg(char *session, char *sender_uid, char **rcpts, char *content, time_t recv_time, int quiet)
{
	int i;

	/* There will be at least 2 INSERTs - 1 into 'messages' table and 1 (at least)
	   into the 'recipients' table. */
	text	*sqlstmt_msg  = (text *)"INSERT INTO messages VALUES(messages_seq.nextval, :session_uid, :sender_uid, :content, :recv_time) RETURNING id INTO :msg_id";
	text	*sqlstmt_rcp  = (text *)"INSERT INTO recipients VALUES(recipients_seq.nextval, :recipient_uid, :msg_id)";

	/* Statement & bind handles */
	OCIStmt *hp_stmt_msg = NULL;
	OCIStmt *hp_stmt_rcp = NULL;
	OCIBind *bind_msg[5] = { NULL };
	OCIBind *bind_rcp[2] = { NULL };

	/* Control vars */
	sword	 retstat  = 0;
	int	 errors   = 0;
	int	 print_errors = (quiet) ? 0 : 1;
	OCIError *hp_error = NULL;

	/* Date handling */
	uword	  invalid = 0;
	OCIDate   oci_recvtime;
	struct tm *tm_recvtime = NULL;		
	
	/* ID of inserted message will be put here */
	OCINumber msg_id;
	int	  init_val = 0;	/* this variable is needed for initialization only */
	

	pthread_mutex_lock(&oralog_oper_lock);
	
	if (!oralog_is_connected()) {
		debug("[logsoracle] can't log msg - not connected\n");
		
		pthread_mutex_unlock(&oralog_oper_lock);
		return 1;
	}


	check_string_len(session);
	check_string_len(sender_uid);
	check_string_len(content);

	/* Create local handles (OCIBind's are created automaticly) */
	OCIHandleAlloc( (dvoid *)hp_env, (dvoid **)&hp_stmt_msg, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0);
	OCIHandleAlloc( (dvoid *)hp_env, (dvoid **)&hp_stmt_rcp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0);
	OCIHandleAlloc( (dvoid *)hp_env, (dvoid **)&hp_error, OCI_HTYPE_ERROR, 0, (dvoid **) 0);	
	
	/* Create DATE in Oracle format */
	tm_recvtime = localtime(&recv_time);
		
	memset(&oci_recvtime, 0, sizeof(OCIDate));
	OCIDateSetTime( &oci_recvtime, (ub1)tm_recvtime->tm_hour, (ub1)tm_recvtime->tm_min, (ub1)tm_recvtime->tm_sec );
	OCIDateSetDate( &oci_recvtime, (sb2)tm_recvtime->tm_year+1900, (ub1)tm_recvtime->tm_mon+1, (ub1)tm_recvtime->tm_mday );

	/* check if provided 'recv_time' was mapped correctly  */
	retstat = OCIDateCheck(hp_error, &oci_recvtime, &invalid);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;

	/* prepare SQL statements */
	debug("[logsoracle] preparing new messages insert statement\n");
	retstat = OCIStmtPrepare(hp_stmt_msg, hp_error, (text *)sqlstmt_msg, (ub4)ora_strlen((char *)sqlstmt_msg), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;	 

	debug("[logsoracle] preparing new recipients insert statement\n");
	retstat = OCIStmtPrepare(hp_stmt_rcp, hp_error, (text *)sqlstmt_rcp, (ub4)ora_strlen((char *)sqlstmt_rcp), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
 

	/* bind the placeholders */
	debug("[logsoracle] binding messages insert..\n");
	   
	retstat = OCIBindByName(hp_stmt_msg, &bind_msg[0], hp_error, (text *) ":session_uid", -1, (dvoid *)session,
				ora_strlen(session)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;

	retstat = OCIBindByName(hp_stmt_msg, &bind_msg[1], hp_error, (text *) ":sender_uid", -1, (dvoid *)sender_uid,
				ora_strlen(sender_uid)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;									    

	retstat = OCIBindByName(hp_stmt_msg, &bind_msg[2], hp_error, (text *) ":content", -1, (dvoid *)content,
				ora_strlen(content)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
	 
	retstat = OCIBindByName(hp_stmt_msg, &bind_msg[3], hp_error, (text *) ":recv_time",
				-1, (dvoid *) &oci_recvtime,
				(sword) sizeof(OCIDate), SQLT_ODT, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;	 
	

	/* Create a new OCINumber - will be under msg_id */
	retstat = OCINumberFromInt(hp_error, &init_val, sizeof(init_val), OCI_NUMBER_SIGNED, &msg_id);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
		
	
	/* bind the OCINumber */
	retstat = OCIBindByName(hp_stmt_msg, &bind_msg[4], hp_error, (text *) ":msg_id",
				-1, (dvoid *) &msg_id,
				(sword) sizeof(msg_id), SQLT_VNU, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
															 

	/* Statement ready - execute */
	debug("[logsoracle] executing insert on messages\n");
	retstat = OCIStmtExecute(hp_service, hp_stmt_msg, hp_error, (ub4) 1, (ub4) 0,
				(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;

	/* You can check recieved message ID like this:
	retstat = OCINumberToInt(hp_error, &msg_id, sizeof(int), OCI_NUMBER_SIGNED, &tmpval);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;	
	debug("[logsoracle] recieved message id: %d\n", tmpval);
	*/
	
	/* Insert into recipients table */
	if(rcpts) {
	    for(i=0; rcpts[i] != NULL; i++) {
		
		check_string_len(rcpts[i]);
		
		debug("[logsoracle] binding recipients\n");
		retstat = OCIBindByName(hp_stmt_rcp, &bind_rcp[0], hp_error, (text *) ":recipient_uid", -1, (dvoid *)rcpts[i],
					ora_strlen(rcpts[i])+1, SQLT_STR, (dvoid *) 0,
					(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
		if(oralog_is_error(hp_error, retstat, print_errors))
		 errors++;	    
	    
	    
		retstat = OCIBindByName(hp_stmt_rcp, &bind_rcp[1], hp_error, (text *) ":msg_id",
					-1, (dvoid *) &msg_id,
					(sword) sizeof(msg_id), SQLT_VNU, (dvoid *) 0,
					(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
		if(oralog_is_error(hp_error, retstat, print_errors))
		 errors++;
		
		debug("[logsoracle] executing insert on recipients\n");
		retstat = OCIStmtExecute(hp_service, hp_stmt_rcp, hp_error, (ub4) 1, (ub4) 0,
					(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
		if(oralog_is_error(hp_error, retstat, print_errors))
		 errors++;
	    }
	}
				    

	/* Commit transaction */
	if(!errors) {
	    debug("[logsoracle] commit\n");
	    OCITransCommit(hp_service, hp_error, (ub4) 0);
	}
	else {
	    debug("[logsoracle] errors present - aborting transaction\n");
	    OCITransRollback(hp_service, hp_error, (ub4) OCI_DEFAULT);
	}


	/* Cleanup (bind handles should be removed as a part of statement) */
	if(hp_stmt_msg)
	    OCIHandleFree(hp_stmt_msg, OCI_HTYPE_STMT);
	if(hp_stmt_rcp)
	    OCIHandleFree(hp_stmt_rcp, OCI_HTYPE_STMT);
	if(hp_error)
	    OCIHandleFree(hp_error, OCI_HTYPE_ERROR);

	pthread_mutex_unlock(&oralog_oper_lock);
	return 0;
}
Esempio n. 18
0
/*
 * Add a new status change to the database
 * Params:
 *  session	- user session name
 *  uid		- uid of person changing status
 *  status	- type of new status (away|back|...)
 *  descr	- new description
 *  change_time - time of status change (no. of seconds since 1st Jan 1970)
 *  quiet	- print error messages or not
 * Returns 0 on success.
 */
int oralog_db_new_status(char *session, char *uid, char *status, char *descr, time_t change_time, int quiet)
{
	OCIStmt	  *hp_stmt = NULL;     /* SQL statement handle */
	OCIBind	  *bind[5] = { NULL }; /* Needed for C-var to SQL-var binding */	
	sword	  retstat  = 0;        /* Return value of function */
	int	  errors   = 0;        /* Error counter */
	uword	  invalid  = 0;        /* for DateCheck() */
	OCIDate   oci_date;	       /* for 'change_time' - oracle internal representation */
	struct tm *tm_chtime = NULL;   /* for 'change_time' - standard C representation */
	
	int	  print_errors = (quiet) ? 0 : 1; /* if nonzero then print errors into status window */
	OCIError  *hp_error   = NULL;		  /* oci error handle */
	
	/* SQL statement to execute */
	text	*sqlstmt = (text *) "INSERT INTO status_changes VALUES( status_changes_seq.nextval, :session_uid, :changes_uid, :status, :descr, :change_time)";


	pthread_mutex_lock(&oralog_oper_lock);

	if (!oralog_is_connected()) {
		debug("[logsoracle] can't log status - not connected\n");
		
		pthread_mutex_unlock(&oralog_oper_lock);
		return 1;
	}


	check_string_len(session);
	check_string_len(uid);
	check_string_len(status);
	check_string_len(descr);


	/* Create local handles (OCIBind's are created automaticly) */
	OCIHandleAlloc( (dvoid *)hp_env, (dvoid **)&hp_stmt, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0);
	OCIHandleAlloc( (dvoid *)hp_env, (dvoid **)&hp_error, OCI_HTYPE_ERROR, 0, (dvoid **) 0);

	/* Create DATE */
	tm_chtime = localtime(&change_time);
	
	memset(&oci_date, 0, sizeof(OCIDate));
	OCIDateSetTime( &oci_date, (ub1)tm_chtime->tm_hour, (ub1)tm_chtime->tm_min, (ub1)tm_chtime->tm_sec ); 
	OCIDateSetDate( &oci_date, (sb2)tm_chtime->tm_year+1900, (ub1)tm_chtime->tm_mon+1, (ub1)tm_chtime->tm_mday );


	/* check if provided 'change_time' was mapped correctly  */
	retstat = OCIDateCheck(hp_error, &oci_date, &invalid);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
			

	/* prepare SQL statement */	
	debug("[logsoracle] preparing new status statement\n");
	retstat = OCIStmtPrepare(hp_stmt, hp_error, (text *)sqlstmt, (ub4)ora_strlen((char *)sqlstmt), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;


	/* bind variables */
	debug("[logsoracle] binding..\n");

	retstat = OCIBindByName(hp_stmt, &bind[0], hp_error, (text *) ":session_uid", -1, (dvoid *)session,
				ora_strlen(session)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;	

				
	retstat = OCIBindByName(hp_stmt, &bind[1], hp_error, (text *) ":changes_uid",
				-1, (dvoid *) uid,
				ora_strlen(uid)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;				


	retstat = OCIBindByName(hp_stmt, &bind[2], hp_error, (text *) ":status",
				-1, (dvoid *) status,
				ora_strlen(status)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;

				
	retstat = OCIBindByName(hp_stmt, &bind[3], hp_error, (text *) ":descr",
				-1, (dvoid *) descr,
				ora_strlen(descr)+1, SQLT_STR, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;


	/* Oracle type DATE can be easily bind by using OCIDate struct and SQLT_ODT datatype */					   
	retstat = OCIBindByName(hp_stmt, &bind[4], hp_error, (text *) ":change_time",
				-1, (dvoid *) &oci_date,
				(sword) sizeof(OCIDate), SQLT_ODT, (dvoid *) 0,
				(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;
						


	/* Statement ready - execute */
	debug("[logsoracle] executing\n");
	retstat = OCIStmtExecute(hp_service, hp_stmt, hp_error, (ub4) 1, (ub4) 0,
				(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
	if(oralog_is_error(hp_error, retstat, print_errors))
	 errors++;


	/* Commit transaction */
	if(!errors) {
		debug("[logsoracle] commit\n");
		OCITransCommit(hp_service, hp_error, (ub4) 0);
	}
	else {
		debug("[logsoracle] errors present - aborting transaction\n");
		OCITransRollback(hp_service, hp_error, (ub4) OCI_DEFAULT);
	}
					
	/* Cleanup (bind handles should be removed as a part of statement) */	
	if(hp_stmt)
	    OCIHandleFree(hp_stmt, OCI_HTYPE_STMT);	
	if(hp_error)
	    OCIHandleFree(hp_error, OCI_HTYPE_ERROR);
	
	pthread_mutex_unlock(&oralog_oper_lock);
	return 0;
}