void PrepareDbTime()
{
   OCIBind *bndv1 = 0;
   OCIBind *bndv2 = 0;

   static text *stmt_cputime = (text *) "begin :cpu_time_value := dbms_utility.get_cpu_time(); end;" ;
   static text *stmt_elptime = (text *) "begin :elp_time_value := dbms_utility.get_time(); end;" ;

   /* Allocate cpu time handle */ 
   CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmt_cputimehp,
                                     OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

   /* Allocate elapsed time handle */ 
   CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmt_elptimehp,
                                     OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

   /* Prepare cpu time statement */
   CheckErr(errhp, OCIStmtPrepare(stmt_cputimehp, errhp, (CONST text *) stmt_cputime,
                                     strlen((char *) stmt_cputime), OCI_NTV_SYNTAX, OCI_DEFAULT));

   /* Prepare elapsed time statement */
   CheckErr(errhp, OCIStmtPrepare(stmt_elptimehp, errhp, (CONST text *) stmt_elptime,
                                     strlen((char *) stmt_elptime), OCI_NTV_SYNTAX, OCI_DEFAULT));

   /* Bind cpu_time_value variable */
   CheckErr(errhp, OCIBindByName(stmt_cputimehp, (OCIBind **) &bndv1, errhp,
                         (text *)":cpu_time_value", (sb4) 15, &cpu_time_value, (sb4) sizeof(ub4), SQLT_INT,
                         (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT));

   /* Bind elp_time_value variable */
   CheckErr(errhp, OCIBindByName(stmt_elptimehp, (OCIBind **) &bndv2, errhp,
                         (text *)":elp_time_value", (sb4) 15, &elp_time_value, (sb4) sizeof(ub4), SQLT_INT,
                         (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT));
}
sword AllocateHandles(ub1 mymem)
{

    if (OCIEnvCreate(&envhp,
                         (ub4) OCI_DEFAULT,
                         (dvoid *)0,
                         (dvoid * (*)(dvoid *, size_t)) 0,
                         (dvoid * (*)(dvoid *, dvoid *, size_t))0,
                         (void (*)(dvoid *, dvoid *)) 0,
                         0,
                         (dvoid **) 0) != OCI_SUCCESS) {
            return OCI_ERROR;
    }
 
    /* allocate an error handle withtin the environment */
    if (OCIHandleAlloc((dvoid *) envhp, (dvoid **) &errhp,
                       (ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0)) {
        printf("OCIHandleAlloc failed for errhp\n");
        return OCI_ERROR;
    }
    
    /* allocate a service context handle within the environment */
    if (OCIHandleAlloc((dvoid *) envhp, (dvoid **) &svchp ,
                       (ub4) OCI_HTYPE_SVCCTX, (size_t) 0, (dvoid **) 0)) {
        printf("OCIHandleAlloc failed for context\n");
        return OCI_ERROR;
    }
    
    return OCI_SUCCESS;
}
static int _doConnect(T C, URL_T url, char**  error) {
#undef ERROR
#define ERROR(e) do {*error = Str_dup(e); return false;} while (0)
#define ORAERROR(e) do{ *error = Str_dup(OracleConnection_getLastError(e)); return false;} while(0)
        const char *database, *username, *password;
        const char *host = URL_getHost(url);
        int port = URL_getPort(url);
        if (! (username = URL_getUser(url)))
                if (! (username = URL_getParameter(url, "user")))
                        ERROR("no username specified in URL");
        if (! (password = URL_getPassword(url)))
                if (! (password = URL_getParameter(url, "password")))
                        ERROR("no password specified in URL");
        if (! (database = URL_getPath(url)))
                ERROR("no database specified in URL");
        ++database;
        /* Create a thread-safe OCI environment with N' substitution turned on. */
        if (OCIEnvCreate(&C->env, OCI_THREADED | OCI_OBJECT | OCI_NCHAR_LITERAL_REPLACE_ON, 0, 0, 0, 0, 0, 0))
                ERROR("Create a OCI environment failed");
        /* allocate an error handle */
        if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->err, OCI_HTYPE_ERROR, 0, 0))
                ERROR("Allocating error handler failed");
        /* server contexts */
        if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->srv, OCI_HTYPE_SERVER, 0, 0))
                ERROR("Allocating server context failed");
        /* allocate a service handle */
        if (OCI_SUCCESS != OCIHandleAlloc(C->env, (dvoid**)&C->svc, OCI_HTYPE_SVCCTX, 0, 0))
                ERROR("Allocating service handle failed");
        StringBuffer_clear(C->sb);
        /* Oracle connect string is on the form: //host[:port]/service name */
        if (host) {
                StringBuffer_append(C->sb, "//%s", host);
                if (port > 0)
                        StringBuffer_append(C->sb, ":%d", port);
                StringBuffer_append(C->sb, "/%s", database);
        } else /* Or just service name */
                StringBuffer_append(C->sb, "%s", database);
        /* Create a server context */
        C->lastError = OCIServerAttach(C->srv, C->err, StringBuffer_toString(C->sb), StringBuffer_length(C->sb), 0);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        /* Set attribute server context in the service context */
        C->lastError = OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, C->srv, 0, OCI_ATTR_SERVER, C->err);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        C->lastError = OCIHandleAlloc(C->env, (void**)&C->usr, OCI_HTYPE_SESSION, 0, NULL);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        C->lastError = OCIAttrSet(C->usr, OCI_HTYPE_SESSION, (dvoid *)username, (int)strlen(username), OCI_ATTR_USERNAME, C->err);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        C->lastError = OCIAttrSet(C->usr, OCI_HTYPE_SESSION, (dvoid *)password, (int)strlen(password), OCI_ATTR_PASSWORD, C->err);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        C->lastError = OCISessionBegin(C->svc, C->err, C->usr, OCI_CRED_RDBMS, OCI_DEFAULT);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                ORAERROR(C);
        OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, C->usr, 0, OCI_ATTR_SESSION, C->err);
        return true;
}
Beispiel #4
0
/*
 * call-seq:
 *   allocate_handles()
 *
 * <b>internal use only</b>
 *
 * Allocates a service context handle, a session handle and a
 * server handle to use explicit attach and begin-session calls.
 */
static VALUE oci8_allocate_handles(VALUE self)
{
    oci8_svcctx_t *svcctx = DATA_PTR(self);
    sword rv;

    if (svcctx->logoff_strategy != NULL) {
        rb_raise(rb_eRuntimeError, "Could not reuse the session.");
    }
    svcctx->logoff_strategy = &complex_logoff;
    svcctx->state = 0;

    /* allocate a service context handle */
    rv = OCIHandleAlloc(oci8_envhp, &svcctx->base.hp.ptr, OCI_HTYPE_SVCCTX, 0, 0);
    if (rv != OCI_SUCCESS)
        oci8_env_raise(oci8_envhp, rv);
    svcctx->base.type = OCI_HTYPE_SVCCTX;

    /* alocalte a session handle */
    rv = OCIHandleAlloc(oci8_envhp, (void*)&svcctx->usrhp, OCI_HTYPE_SESSION, 0, 0);
    if (rv != OCI_SUCCESS)
        oci8_env_raise(oci8_envhp, rv);
    copy_session_handle(svcctx);

    /* alocalte a server handle */
    rv = OCIHandleAlloc(oci8_envhp, (void*)&svcctx->srvhp, OCI_HTYPE_SERVER, 0, 0);
    if (rv != OCI_SUCCESS)
        oci8_env_raise(oci8_envhp, rv);
    copy_server_handle(svcctx);
    return self;
}
Beispiel #5
0
int main(int argc, char *argv[])
{
  OCIError *errhp = NULL;

  printf("stage4: Demonstrating OCI statement caching \n");

  /* parse command line options */
  parse_options(argc, argv);
  
  checkenv(envhp, OCIEnvCreate(&envhp,                /* returned env handle */
                               OCI_THREADED,         /* initialization modes */
                               NULL, NULL, NULL, NULL, /* callbacks, context */
                               (size_t) 0,    /* extra memory size: optional */
                               (void **) NULL));    /* returned extra memory */

  /* allocate error handle
   * note: for OCIHandleAlloc(), we always check error on environment handle
   */
  checkenv(envhp, OCIHandleAlloc(envhp,                /* environment handle */
                                 (void **) &errhp,    /* returned err handle */
                                 OCI_HTYPE_ERROR,/*type of handle to allocate*/
                                 (size_t) 0,  /* extra memory size: optional */
                                 (void **) NULL));  /* returned extra memory */

  create_session_pool(envhp, errhp, &poolName, &poolNameLen);

  /* allocate auth handle
   * note: for OCIHandleAlloc(), we check error on environment handle
   */
  checkenv(envhp, OCIHandleAlloc(envhp,
                          (void **) &authp, OCI_HTYPE_AUTHINFO,
                          (size_t) 0, (void **) NULL));

  /* setup username and password */
  checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
                             (void *) username, strlen((char *)username),
                             OCI_ATTR_USERNAME, errhp));

  checkerr(errhp, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
                            apppassword, strlen((char *) apppassword),
                            OCI_ATTR_PASSWORD, errhp));

  spawn_threads(envhp, errhp, &thread_function);
  
  /* Destroy the session pool */
  OCISessionPoolDestroy(spoolhp, errhp, OCI_DEFAULT);

  /* clean up */
  if (authp)
    OCIHandleFree(authp, OCI_HTYPE_AUTHINFO);
  if (spoolhp)
    OCIHandleFree(spoolhp, OCI_HTYPE_SPOOL); 
  if (errhp)
    OCIHandleFree(errhp, OCI_HTYPE_ERROR);
  if (envhp)
    OCIHandleFree(envhp, OCI_HTYPE_ENV);
  
  return 0;
}
Beispiel #6
0
ocisession::ocisession(const char * connect_str, const int connect_str_len,
					   const char * user_name, const int user_name_len,
					   const char * password, const int password_len)
{
	intf_ret r;
	OCIAuthInfo *authp = NULL;

	init();

	r.handle = envhp;

	// allocate error handle
	checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp,	/* environment handle */
                            (void **) &_errhp,	/* returned err handle */
                            OCI_HTYPE_ERROR,	/* typ of handle to allocate */
                            (size_t) 0,			/* optional extra memory size */
                            (void **) NULL));	/* returned extra memeory */

	if(r.fn_ret != SUCCESS) {
   		REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf);
        throw r;
	}

	// allocate auth handle
	checkenv(&r, OCIHandleAlloc((OCIEnv*)envhp,
							(void**)&authp, OCI_HTYPE_AUTHINFO,
							(size_t)0, (void **) NULL));

	r.handle = _errhp;

	// usrname and password
	checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
								(void*) user_name, user_name_len,
								OCI_ATTR_USERNAME, (OCIError *)_errhp));
	checkerr(&r, OCIAttrSet(authp, OCI_HTYPE_AUTHINFO,
								(void*) password, password_len,
								OCI_ATTR_PASSWORD, (OCIError *)_errhp));


    /* get the database connection */
    checkerr(&r, OCISessionGet((OCIEnv*)envhp, (OCIError *)_errhp,
                               (OCISvcCtx**)&_svchp,					/* returned database connection */
                               authp,									/* initialized authentication handle */                               
                               (OraText *) connect_str, connect_str_len,/* connect string */
                               NULL, 0, NULL, NULL, NULL,				/* session tagging parameters: optional */
                               OCI_SESSGET_STMTCACHE));					/* modes */
	if(r.fn_ret != SUCCESS) {
		REMOTE_LOG("failed OCISessionGet %s\n", r.gerrbuf);
        throw r;
	}

	(void) OCIHandleFree(authp, OCI_HTYPE_AUTHINFO);

	REMOTE_LOG("got session %p\n", _svchp);

	_sessions.push_back(this);
}
Beispiel #7
0
void InitHandles() {
	if (OCIEnvCreate(&henv, OCI_DEFAULT, NULL, NULL, NULL, NULL, 0, NULL) ||
		OCIHandleAlloc(henv, (dvoid*)&hser, OCI_HTYPE_SERVER, 0, NULL) ||
		OCIHandleAlloc(henv, (dvoid*)&herr, OCI_HTYPE_ERROR, 0, NULL) ||
		OCIHandleAlloc(henv, (dvoid*)&husr, OCI_HTYPE_SESSION, 0, NULL) ||
		OCIHandleAlloc(henv, (dvoid*)&hsvc, OCI_HTYPE_SVCCTX, 0, NULL) ||
		OCIHandleAlloc(henv, (dvoid*)&hsql, OCI_HTYPE_STMT, 0, NULL)) {
		Log("initialize handles failed");
		exit(2);
	}
}
Beispiel #8
0
/*************************************************************************
 *
 *	Function: sql_init_socket
 *
 *	Purpose: Establish connection to the db
 *
 *************************************************************************/
static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {

	rlm_sql_oracle_sock *oracle_sock;

	if (!sqlsocket->conn) {
		sqlsocket->conn = (rlm_sql_oracle_sock *)rad_malloc(sizeof(rlm_sql_oracle_sock));
		if (!sqlsocket->conn) {
			return -1;
		}
	}
	memset(sqlsocket->conn,0,sizeof(rlm_sql_oracle_sock));

	oracle_sock = sqlsocket->conn;

	if (OCIEnvCreate(&oracle_sock->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0,
		(dvoid * (*)(dvoid *, size_t)) 0,
		(dvoid * (*)(dvoid *, dvoid *, size_t))0,
		(void (*)(dvoid *, dvoid *)) 0,
		0, (dvoid **)0 )) {
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle OCI environment (OCIEnvCreate())");
		return -1;
	}

	if (OCIHandleAlloc((dvoid *) oracle_sock->env, (dvoid **) &oracle_sock->errHandle,
		(ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0))
	{
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle ERROR handle (OCIHandleAlloc())");
		return -1;
	}

	/* Allocate handles for select and update queries */
	if (OCIHandleAlloc((dvoid *)oracle_sock->env, (dvoid **) &oracle_sock->queryHandle,
				(ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0))
	{
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s",
			sql_error(sqlsocket, config));
		return -1;
	}


	if (OCILogon(oracle_sock->env, oracle_sock->errHandle, &oracle_sock->conn,
			config->sql_login, strlen(config->sql_login),
			config->sql_password,  strlen(config->sql_password),
			config->sql_db, strlen(config->sql_db)))
	{
		radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(sqlsocket, config));
		sql_close(sqlsocket,config);
		return -1;
	}

	return 0;
}
sword ConnectToDb(const char* const uid, const char* const pwd)
{
    sword orc;

    /* allocate Server and Authentication (Session) handles */
    orc = OCIHandleAlloc((dvoid *) envhp, 
                         (dvoid **) &srvhp,
                         (ub4) OCI_HTYPE_SERVER, 
                         (size_t) 0, (dvoid **) 0);

    orc = OCIHandleAlloc((dvoid *) envhp, 
                         (dvoid **) &authp,
                         (ub4) OCI_HTYPE_SESSION, 
                         (size_t) 0, (dvoid **) 0);
    
    /* attach to the server */
    orc = OCIServerAttach(srvhp, errhp, (text *) 0, 0, (ub4) OCI_DEFAULT);
     
    orc = OCIAttrSet((dvoid *) authp, 
                     (ub4) OCI_HTYPE_SESSION,
                     (dvoid *) uid, (ub4) strlen((char *)uid),
                     (ub4) OCI_ATTR_USERNAME, errhp);
    
    orc = OCIAttrSet((dvoid *) authp, 
                     (ub4) OCI_HTYPE_SESSION,
                     (dvoid *) pwd, (ub4) strlen((char *)pwd),
                     (ub4) OCI_ATTR_PASSWORD, errhp);

    /* set the server attribute in the service context */
    orc = OCIAttrSet((dvoid *) svchp, 
                     (ub4) OCI_HTYPE_SVCCTX,
                     (dvoid *) srvhp, 
                     (ub4) 0, (ub4) OCI_ATTR_SERVER, errhp);
     
    /* log on */
    orc = OCISessionBegin(svchp, errhp, authp, 
                          (ub4) OCI_CRED_RDBMS,
                          (ub4) OCI_DEFAULT);
     
    CheckErr(errhp, orc);

    /* set the session attribute in the service context */
    orc = OCIAttrSet((dvoid *) svchp, (ub4) OCI_HTYPE_SVCCTX, 
                     (dvoid *) authp,
                     (ub4) 0, (ub4) OCI_ATTR_SESSION, errhp);

    return (orc);
} /* ConnectToDb */
Beispiel #10
0
int dbd_oracle_statement_create(lua_State *L, connection_t *conn, const char *sql_query) { 
    int rc;
    statement_t *statement = NULL;
    OCIStmt *stmt;
    char *new_sql;

    /*
     * convert SQL string into a Oracle API compatible SQL statement
     */
    new_sql = replace_placeholders(L, ':', sql_query);

    rc = OCIHandleAlloc((dvoid *)conn->oracle, (dvoid **)&stmt, OCI_HTYPE_STMT, 0, (dvoid **)0);
    rc = OCIStmtPrepare(stmt, conn->err, new_sql, strlen(new_sql), (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);

    free(new_sql);

    statement = (statement_t *)lua_newuserdata(L, sizeof(statement_t));
    statement->conn = conn;
    statement->stmt = stmt;
    statement->num_columns = 0;
    statement->bind = NULL;
    statement->metadata = 0;

    luaL_getmetatable(L, DBD_ORACLE_STATEMENT);
    lua_setmetatable(L, -2);

    return 1;
} 
Beispiel #11
0
/*
 * call-seq:
 *   OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, username = nil, password = nil, dbname = nil) -> connection pool
 *   OCI8::ConnectionPool.new(conn_min, conn_max, conn_incr, connect_string) -> connection pool
 *
 * Creates a connection pool.
 *
 * <i>conn_min</i> specifies the minimum number of connections in the
 * connection pool. Valid values are 0 and higher.
 *
 * <i>conn_max</i> specifies the maximum number of connections that
 * can be opened to the database. Once this value is reached, no more
 * connections are opened. Valid values are 1 and higher.
 *
 * <i>conn_incr</i> allows the application to set the next increment
 * for connections to be opened to the database if the current number
 * of connections are less than <i>conn_max</i>. Valid values are 0
 * and higher.
 *
 * <i>username</i> and <i>password</i> are required to establish an
 * implicit primary session. When both are nil, external
 * authentication is used.
 *
 * <i>dbname</i> specifies the database server to connect to.
 *
 * If the number of arguments is four, <i>username</i>,
 * <i>password</i> and <i>dbname</i> are extracted from the fourth
 * argument <i>connect_string</i>. The syntax is "username/password" or
 * "username/password@dbname".
 */
static VALUE oci8_cpool_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE conn_min;
    VALUE conn_max;
    VALUE conn_incr;
    VALUE username;
    VALUE password;
    VALUE dbname;
    oci8_cpool_t *cpool = DATA_PTR(self);
    OraText *pool_name;
    sb4 pool_name_len;
    sword rv;

    /* check arguments */
    rb_scan_args(argc, argv, "42", &conn_min, &conn_max, &conn_incr,
                 &username, &password, &dbname);
    Check_Type(conn_min, T_FIXNUM);
    Check_Type(conn_max, T_FIXNUM);
    Check_Type(conn_incr, T_FIXNUM);
    if (argc == 4) {
        VALUE mode;
        VALUE conn_str = username;

        OCI8SafeStringValue(conn_str);
        oci8_do_parse_connect_string(conn_str, &username, &password, &dbname, &mode);
        if (!NIL_P(mode)) {
            rb_raise(rb_eArgError, "invalid connect string \"%s\": Connection pooling doesn't support sysdba and sysoper privileges.", RSTRING_PTR(conn_str));
        }
    } else {
        if (!NIL_P(username)) {
            OCI8SafeStringValue(username);
        }
        if (!NIL_P(password)) {
            OCI8SafeStringValue(password);
        }
        if (!NIL_P(dbname)) {
            OCI8SafeStringValue(dbname);
        }
    }

    rv = OCIHandleAlloc(oci8_envhp, &cpool->base.hp.ptr, OCI_HTYPE_CPOOL, 0, NULL);
    if (rv != OCI_SUCCESS)
        oci8_env_raise(oci8_envhp, rv);
    cpool->base.type = OCI_HTYPE_CPOOL;

    oci_lc(OCIConnectionPoolCreate(oci8_envhp, oci8_errhp, cpool->base.hp.poolhp,
                                   &pool_name, &pool_name_len,
                                   NIL_P(dbname) ? NULL : RSTRING_ORATEXT(dbname),
                                   NIL_P(dbname) ? 0 : RSTRING_LEN(dbname),
                                   FIX2UINT(conn_min), FIX2UINT(conn_max),
                                   FIX2UINT(conn_incr),
                                   NIL_P(username) ? NULL : RSTRING_ORATEXT(username),
                                   NIL_P(username) ? 0 : RSTRING_LEN(username),
                                   NIL_P(password) ? NULL : RSTRING_ORATEXT(password),
                                   NIL_P(password) ? 0 : RSTRING_LEN(password),
                                   OCI_DEFAULT));
    cpool->pool_name = rb_str_new(TO_CHARPTR(pool_name), pool_name_len);
    rb_str_freeze(cpool->pool_name);
    return Qnil;
}
Beispiel #12
0
        void Statement::Prepare(std::string const& sqlBlock)
        {
            ASSERT(m_conn != NULL && sqlBlock.empty() != true);
            ASSERT(m_stmtHandle == NULL);
            sword result;

            result  = OCIHandleAlloc(m_conn->m_environmentHandle
                        , (void **) &m_stmtHandle,OCI_HTYPE_STMT, 0, NULL);
            if(result == OCI_SUCCESS)
            {
                result  = OCIStmtPrepare(m_stmtHandle, m_conn->m_errorHandle
                            , (text*) sqlBlock.c_str(), sqlBlock.size(), OCI_NTV_SYNTAX, OCI_DEFAULT);
            }
            else
            {
                throw Error (result, m_conn->m_environmentHandle, __FILE__, __LINE__);
            }
            if(result == OCI_SUCCESS)
            {
                ub2 stmtType = 0;
                result = OCIAttrGet (m_stmtHandle, OCI_HTYPE_STMT
                        , &stmtType, NULL, OCI_ATTR_STMT_TYPE, m_conn->m_errorHandle);
                m_type = (StatementType)stmtType;
            }
            if( result == OCI_SUCCESS)
            {
                m_isPrepared = true;
                m_isExecuted = false; 
            }
            else
            {
                throw Error (result, m_conn->m_errorHandle, __FILE__, __LINE__);
            }
        }
Beispiel #13
0
static int db_getn(int type, int keytype)
{
    int        n = 0;
    char       table[20];
    char      *sql =  "select count(*) as n from %s where type=%d";
    OraText    row[4000];
    OCIDefine *dnp = NULL;

    strcpy(table, (type == TYPE_KILL)? "kill_key" : "monitor_key");
    sprintf((char*)row, sql,table, keytype);
    checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp,
                            OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), myerrhp);
    checkerr(OCIStmtPrepare(mystmthp, myerrhp, row, (ub4)strlen((char*)row),
                            (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT), myerrhp);
    checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, (ub4)0, (ub4)0,
                            (CONST OCISnapshot *)0, (OCISnapshot *)0,
                            OCI_DEFAULT), myerrhp);
    if ((status = OCIDefineByPos(mystmthp, &dnp, myerrhp, 1, &n, sizeof(n),
                                 SQLT_INT, (dvoid *)0, 0, (ub2 *)0,
                                 OCI_DEFAULT))) {
        checkerr(status, myerrhp);
        return -1;
    }
    if(OCIStmtFetch2(mystmthp, myerrhp, 1, OCI_FETCH_NEXT, 0,
                     OCI_DEFAULT) != OCI_NO_DATA) {
        return n;
    }
    return 0;
}
Beispiel #14
0
static int o_init (void) /* {{{ */
{
  int status;

  if (oci_env != NULL)
    return (0);

  status = OCIEnvCreate (&oci_env,
      /* mode = */ OCI_THREADED,
      /* context        = */ NULL,
      /* malloc         = */ NULL,
      /* realloc        = */ NULL,
      /* free           = */ NULL,
      /* user_data_size = */ 0,
      /* user_data_ptr  = */ NULL);
  if (status != 0)
  {
    ERROR ("oracle plugin: OCIEnvCreate failed with status %i.", status);
    return (-1);
  }

  status = OCIHandleAlloc (oci_env, (void *) &oci_error, OCI_HTYPE_ERROR,
      /* user_data_size = */ 0, /* user_data = */ NULL);
  if (status != OCI_SUCCESS)
  {
    ERROR ("oracle plugin: OCIHandleAlloc (OCI_HTYPE_ERROR) failed "
        "with status %i.", status);
    return (-1);
  }

  return (0);
} /* }}} int o_init */
int CheckLobType()
{
   OCIStmt *stmtlobtypehp;
   OCIDefine *defv1 = 0;
   char LobType[4];

   static text *stmt_lobtype  = (text *)"SELECT securefile from user_lobs where table_name='FOO' and column_name='DOCUMENT' ";

   LobType[3]='\0';

   CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmtlobtypehp,
                                     OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

   CheckErr(errhp, OCIStmtPrepare(stmtlobtypehp, errhp, (CONST text *) stmt_lobtype,
                                     strlen((char *) stmt_lobtype), OCI_NTV_SYNTAX, OCI_DEFAULT));

   CheckErr(errhp, OCIDefineByPos (stmtlobtypehp, (OCIDefine **) &defv1, errhp,
                         1, &LobType, 4, SQLT_STR,
                         (dvoid *)0, (ub2 *)0, (ub2 *)0, OCI_DEFAULT));

   CheckErr(errhp, OCIStmtExecute(svchp, stmtlobtypehp, errhp, (ub4) 1, (ub4) 0,
                                     (CONST OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT));
  if ( (strcmp(LobType, "YES")) == 0 ) 
     return (1) ;
  else
     return (0) ;

}
Beispiel #16
0
ResultSet_T OracleConnection_executeQuery(T C, const char *sql, va_list ap) {
        OCIStmt* stmtp;
        va_list  ap_copy;
        assert(C);
        C->rowsChanged = 0;
        va_copy(ap_copy, ap);
        StringBuffer_vset(C->sb, sql, ap_copy);
        va_end(ap_copy);
        StringBuffer_trim(C->sb);
        /* Build statement */
        C->lastError = OCIHandleAlloc(C->env, (void **)&stmtp, OCI_HTYPE_STMT, 0, NULL);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                return NULL;
        C->lastError = OCIStmtPrepare(stmtp, C->err, StringBuffer_toString(C->sb), StringBuffer_length(C->sb), OCI_NTV_SYNTAX, OCI_DEFAULT);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) {
                OCIHandleFree(stmtp, OCI_HTYPE_STMT);
                return NULL;
        }
        /* Execute and create Result Set */
        C->lastError = OCIStmtExecute(C->svc, stmtp, C->err, 0, 0, NULL, NULL, OCI_DEFAULT);    
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO) {
                ub4 parmcnt = 0;
                OCIAttrGet(stmtp, OCI_HTYPE_STMT, &parmcnt, NULL, OCI_ATTR_PARSE_ERROR_OFFSET, C->err);
                DEBUG("Error occured in StmtExecute %d (%s), offset is %d\n", C->lastError, OracleConnection_getLastError(C), parmcnt);
                OCIHandleFree(stmtp, OCI_HTYPE_STMT);
                return NULL;
        }
        C->lastError = OCIAttrGet(stmtp, OCI_HTYPE_STMT, &C->rowsChanged, 0, OCI_ATTR_ROW_COUNT, C->err);
        if (C->lastError != OCI_SUCCESS && C->lastError != OCI_SUCCESS_WITH_INFO)
                DEBUG("OracleConnection_execute: Error in OCIAttrGet %d (%s)\n", C->lastError, OracleConnection_getLastError(C));
        return ResultSet_new(OracleResultSet_new(stmtp, C->env, C->usr, C->err, C->svc, true, C->maxRows), (Rop_T)&oraclerops);
}
Beispiel #17
0
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
	env_data *env;
	conn_data *conn = getconnection (L);
	const char *statement = luaL_checkstring (L, 2);
	sword status;
	ub4 prefetch = 0;
	ub4 iters;
	ub4 mode;
	ub2 type;
	OCIStmt *stmthp;

	/* get environment */
	lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env);
	if (!lua_isuserdata (L, -1))
		luaL_error(L,LUASQL_PREFIX"invalid environment in connection!");
	env = (env_data *)lua_touserdata (L, -1);
	/* statement handle */
	ASSERT (L, OCIHandleAlloc ((dvoid *)env->envhp, (dvoid **)&stmthp,
		OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), conn->errhp);
	ASSERT (L, OCIAttrSet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
		(dvoid *)&prefetch, (ub4)0, (ub4)OCI_ATTR_PREFETCH_ROWS,
		conn->errhp), conn->errhp);
	ASSERT (L, OCIStmtPrepare (stmthp, conn->errhp, (text *)statement,
		(ub4) strlen(statement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT),
		conn->errhp);
	/* statement type */
	ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4) OCI_HTYPE_STMT,
		(dvoid *)&type, (ub4 *)0, (ub4)OCI_ATTR_STMT_TYPE, conn->errhp),
		conn->errhp);
	if (type == OCI_STMT_SELECT)
		iters = 0;
	else
		iters = 1;
	if (conn->auto_commit)
		mode = OCI_COMMIT_ON_SUCCESS;
	else
		mode = OCI_DEFAULT;
	/* execute statement */
	status = OCIStmtExecute (conn->svchp, stmthp, conn->errhp, iters,
		(ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, mode);
	if (status && (status != OCI_NO_DATA)) {
		OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
		return checkerr (L, status, conn->errhp);
	}
	if (type == OCI_STMT_SELECT) {
		/* create cursor */
		return create_cursor (L, 1, conn, stmthp, statement);
	} else {
		/* return number of rows */
		int rows_affected;
		ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
			(dvoid *)&rows_affected, (ub4 *)0,
			(ub4)OCI_ATTR_ROW_COUNT, conn->errhp), conn->errhp);
		OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
		lua_pushnumber (L, rows_affected);
		return 1;
	}
}
Beispiel #18
0
OWStatement::OWStatement( OWConnection* pConnect, const char* pszStatement )
{
    poConnection    = pConnect;
    nStmtMode       = OCI_DEFAULT;
    nNextCol        = 0;
    nNextBnd        = 0;
    hError          = poConnection->hError;

    //  -----------------------------------------------------------
    //  Create Statement handler
    //  -----------------------------------------------------------

    OCIStmt* hStatement;

    CheckError( OCIHandleAlloc( (dvoid*) poConnection->hEnv,
        (dvoid**) (dvoid*) &hStatement,
        (ub4) OCI_HTYPE_STMT,
        (size_t) 0,
        (dvoid**) NULL), hError );

    hStmt = hStatement;   // Save Statement Handle

    //  -----------------------------------------------------------
    //  Prepare Statement
    //  -----------------------------------------------------------

    CheckError( OCIStmtPrepare( hStmt,
        hError,
        (text*) pszStatement,
        (ub4) strlen(pszStatement),
        (ub4) OCI_NTV_SYNTAX,
        (ub4) OCI_DEFAULT ), hError );

    //  -----------------------------------------------------------
    //  Get Statement type
    //  -----------------------------------------------------------

    ub2 nStmtType;

    CheckError( OCIAttrGet( (dvoid*) hStmt,
        (ub4) OCI_HTYPE_STMT,
        (dvoid*) &nStmtType,
        (ub4*) 0,
        (ub4) OCI_ATTR_STMT_TYPE,
        hError ), hError );

    //  -----------------------------------------------------------
    //  Set Statement mode
    //  -----------------------------------------------------------

    if( nStmtType != OCI_STMT_SELECT )
    {
        nStmtMode = OCI_DEFAULT;
    }

    CPLDebug("PL/SQL","\n%s\n", pszStatement);
}
Beispiel #19
0
DpiHandle * EnvImpl::allocHandle(HandleType handleType)
{
  void *handle = NULL;

  ociCallEnv(OCIHandleAlloc(envh_, &handle, handleType, 0, NULL),
             envh_);

  return (DpiHandle *)handle;
}
/*************************************************************************
 *
 *	Function: sql_socket_init
 *
 *	Purpose: Establish connection to the db
 *
 *************************************************************************/
static int sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {

	rlm_sql_oracle_conn_t *conn;

	MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_oracle_conn_t));
	talloc_set_destructor((void *) conn, sql_socket_destructor);

	if (OCIEnvCreate(&conn->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0,
		(dvoid * (*)(dvoid *, size_t)) 0,
		(dvoid * (*)(dvoid *, dvoid *, size_t))0,
		(void (*)(dvoid *, dvoid *)) 0,
		0, (dvoid **)0 )) {
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle OCI environment (OCIEnvCreate())");
		return -1;
	}

	if (OCIHandleAlloc((dvoid *) conn->env, (dvoid **) &conn->errHandle,
		(ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0))
	{
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle ERROR handle (OCIHandleAlloc())");
		return -1;
	}

	/* Allocate handles for select and update queries */
	if (OCIHandleAlloc((dvoid *)conn->env, (dvoid **) &conn->queryHandle,
				(ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0))
	{
		radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s",
			sql_error(handle, config));
		return -1;
	}


	if (OCILogon(conn->env, conn->errHandle, &conn->ctx,
			config->sql_login, strlen(config->sql_login),
			config->sql_password,  strlen(config->sql_password),
			config->sql_db, strlen(config->sql_db)))
	{
		radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(handle, config));
		return -1;
	}

	return 0;
}
Beispiel #21
0
	connection(asio::io_service& io_service) :
		sql::detail::connection_base<detail::service>(io_service)
	{
		if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&server),
				OCI_HTYPE_SERVER, 0, 0))
			throw std::bad_alloc();

		if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&error),
				OCI_HTYPE_ERROR, 0, 0))
			throw std::bad_alloc();

		if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&svcctx),
				OCI_HTYPE_SVCCTX, 0, 0))
			throw std::bad_alloc();

		if (OCIHandleAlloc(service.env(), reinterpret_cast<dvoid**> (&session),
				OCI_HTYPE_SESSION, 0, 0))
			throw std::bad_alloc();
	}
Beispiel #22
0
int db_insert(mail_t *mail, char *keyword, int type, unsigned short port)
{
    OraText Insertp[SQL_MAXLINE];
    OCIBind *bind1 = NULL;
    OCIBind *bind2 = NULL;
    char table[20];
    char keywordselect[100];
    char *sql = "insert into %s values(id_seq.nextval,sysdate,'%s','%s','%s','%s', :1,'%s', :2,%d)";

    assert(mail);
    assert(keyword);
    if (type == TYPE_KILL) {
        strcpy(table, "kill_log");
    } else if (type == TYPE_MONITOR) {
        strcpy(table, "monitor_log");
    } else {
        strcpy(table, "spam_log");
    }
    strcpy(keywordselect, keyword);
    pretreatment(mail, keywordselect);
    /* 插入 */
    sprintf((char*)Insertp, sql, table, keywordselect, mail->from, mail->to,
            mail->subject, mail->attach_name, port);
    DEBUG("In Progressing:%s\n",Insertp);
    checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp,
                            OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), myerrhp);
    checkerr(OCIStmtPrepare(mystmthp, myerrhp, Insertp,
                            (ub4)strlen((char*)Insertp),
                            (ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT), myerrhp);
    DEBUG("content: %s\n attach_content: %s\n", mail->content,
          mail->attach_content);
    checkerr(OCIBindByPos(mystmthp, &bind1, myerrhp, 1,
                          mail->content, strlen(mail->content) + 1,
                          SQLT_STR, NULL, NULL, NULL, 0, NULL, OCI_DEFAULT),
             myerrhp);
    checkerr(OCIBindByPos(mystmthp, &bind2, myerrhp, 2,
                          mail->attach_content, strlen(mail->attach_content) + 1,
                          SQLT_STR, NULL, NULL, NULL, 0, NULL, OCI_DEFAULT),
             myerrhp);
    checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, (ub4)1, (ub4)0,
                            (CONST OCISnapshot *)0, (OCISnapshot *)0,
                            OCI_DEFAULT), myerrhp);
    checkerr(OCITransCommit(mysvchp, myerrhp, (ub4)0), myerrhp);

    assert(mail->content);
    assert(mail->attach_content);
    if (strcmp(mail->content, "") == 0) {
        mail->content = NULL;
    }
    if (strcmp(mail->attach_content, "") == 0) {
        mail->attach_content = NULL;
    }
    return 0;
}
Beispiel #23
0
/* Function to get an array of REFs to populate the varray of REFs*/
static void getRef()
{
  OCIDefine *defhp = (OCIDefine *) 0; /* For the REF column */
  i_residence *sub_obj[NUMREC];
  ub4 subsize[NUMREC];
  ub4 pos = 0;
  ub4 arraySize = NUMREC;

  OCIHandleAlloc(envhp, (dvoid **) &stmthp, OCI_HTYPE_STMT, (size_t) 0,
    ((dvoid **) 0));

  if((status = OCIStmtPrepare(stmthp, errhp, (text *) selRef,
    (ub4) strlen((char *) selRef), OCI_NTV_SYNTAX, OCI_DEFAULT)) != OCI_SUCCESS)
  {
    printf("OciStmtPrepare - Failure\n");
  }

  if((status = OCIObjectNew(envhp, errhp, svchp, OCI_TYPECODE_REF,
    (OCIType *) 0, (dvoid *) 0, OCI_DURATION_DEFAULT, FALSE,
    (dvoid **) workadd)) != OCI_SUCCESS)
  {
    printf("OCIObjectNew - Failure\n");
  }

  if((status = OCIDefineByPos(stmthp, &defhp, errhp, (ub4) 1, (dvoid *) 0,
    (sb4) 0, SQLT_REF, (dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) OCI_DEFAULT ))
    != OCI_SUCCESS)
  {
    printf("OCIDefineByPos - Failure\n");
  }

  if((status = OCIDefineObject(defhp, errhp, (OCIType *) 0, (dvoid **) workadd,
    subsize, (dvoid **) 0, (ub4 *) 0)) != OCI_SUCCESS)
  {
    printf("OCIDefineObject - failure\n");
  }

  if((status = OCIStmtExecute(svchp, stmthp, errhp, (ub4) NUMREC, (ub4) 0,
    (OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT)) != OCI_SUCCESS)
  {
    printf("OCIStmtExecute - Failure\n");
  }
  else
  {
    if((status = OCIObjectArrayPin(envhp, errhp, workadd, (ub4) arraySize,
      (OCIComplexObject **) 0, 0, OCI_PIN_ANY, OCI_DURATION_SESSION,
      OCI_LOCK_NONE, (dvoid **) sub_obj, (ub4 *) &pos)) != OCI_SUCCESS)
    {
      printf("OCIObjectArrayPin - Failure\n");
    }
  }
  OCIHandleFree((dvoid *) stmthp, OCI_HTYPE_STMT);
} /* End of getRef() */
Beispiel #24
0
/*
   Allocate the environment structure for use by the SQL routines.
*/
int
cllOpenEnv( icatSessionStruct *icss ) {
    int             stat;

    OCIEnv           *p_env;
    OCISvcCtx        *p_svc;

    stat = OCIEnvCreate( ( OCIEnv ** )&p_env,
                         ( ub4 )OCI_DEFAULT,
                         ( dvoid * )0, ( dvoid * ( * )( dvoid *, size_t ) )0,
                         ( dvoid * ( * )( dvoid *, dvoid *, size_t ) )0,
                         ( void ( * )( dvoid *, dvoid * ) )0,
                         ( size_t )0, ( dvoid ** )0 );
    if ( stat != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllOpenEnv: OCIEnvCreate failed" );
        return CAT_ENV_ERR;
    }

    /* Initialize handles */
    stat = OCIHandleAlloc( ( dvoid * ) p_env, ( dvoid ** ) &p_err, OCI_HTYPE_ERROR,
                           ( size_t ) 0, ( dvoid ** ) 0 );

    if ( stat != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllOpenEnv: OCIHandleAlloc failed" );
        return CAT_ENV_ERR;
    }

    stat = OCIHandleAlloc( ( dvoid * ) p_env, ( dvoid ** ) &p_svc, OCI_HTYPE_SVCCTX,
                           ( size_t ) 0, ( dvoid ** ) 0 );

    if ( stat != OCI_SUCCESS ) {
        rodsLog( LOG_ERROR, "cllOpenEnv: OCIHandleAlloc failed" );
        return CAT_ENV_ERR;
    }

    icss->connectPtr = p_svc;
    icss->environPtr = p_env;

    return 0;
}
Beispiel #25
0
int  OracleConnection_beginTransaction(T C) {
        assert(C);
        if (C->txnhp == NULL) /* Allocate handler only once, if it is necessary */
        {
            /* allocate transaction handle and set it in the service handle */
            C->lastError = OCIHandleAlloc(C->env, (void **)&C->txnhp, OCI_HTYPE_TRANS, 0, 0);
            if (C->lastError != OCI_SUCCESS) 
                return false;
            OCIAttrSet(C->svc, OCI_HTYPE_SVCCTX, (void *)C->txnhp, 0, OCI_ATTR_TRANS, C->err);
        }
        C->lastError = OCITransStart (C->svc, C->err, ORACLE_TRANSACTION_PERIOD, OCI_TRANS_NEW);
        return (C->lastError == OCI_SUCCESS);
}
Beispiel #26
0
int db_init(char *servername, char *username, char *passwd)
{
    OCIEnvCreate(&myenvhp, OCI_THREADED|OCI_OBJECT, (dvoid *)0, 0, 0, 0,
                 (size_t)0, (dvoid **)0);
    OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mysrvhp, OCI_HTYPE_SERVER, 0,
                   (dvoid **)0);
    OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&myerrhp, OCI_HTYPE_ERROR, 0,
                   (dvoid **)0);
    /* 服务名 */
    status = OCIServerAttach(mysrvhp, myerrhp, (const OraText*)servername,
                             strlen(servername), OCI_DEFAULT);
    if (status != OCI_SUCCESS && status != OCI_SUCCESS_WITH_INFO) {
        checkerr(status, myerrhp);
        OCIServerDetach(mysrvhp, myerrhp, OCI_DEFAULT);
        return -1;
    }
    OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mysvchp, OCI_HTYPE_SVCCTX, 0,
                   (dvoid **)0);
    OCIAttrSet((dvoid *)mysvchp, OCI_HTYPE_SVCCTX, (dvoid *)mysrvhp, (ub4)0,
               OCI_ATTR_SERVER, myerrhp);
    OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&myusrhp, OCI_HTYPE_SESSION, 0,
                   (dvoid **)0);
    OCIAttrSet((dvoid *)myusrhp, OCI_HTYPE_SESSION, (dvoid *)username,
               (ub4)strlen(username), OCI_ATTR_USERNAME, myerrhp);
    OCIAttrSet((dvoid *)myusrhp, OCI_HTYPE_SESSION, (dvoid *)passwd,
               (ub4)strlen(passwd), OCI_ATTR_PASSWORD, myerrhp);

    if(OCISessionBegin((dvoid *)mysvchp, myerrhp, myusrhp, OCI_CRED_RDBMS,
                       OCI_DEFAULT) != OCI_SUCCESS) {
        DEBUG("Build the talking fail!\n");
        OCIHandleFree((void *)myenvhp, OCI_HTYPE_ENV);
        return -1;
    }
    OCIAttrSet((dvoid *)mysvchp, OCI_HTYPE_SVCCTX, (dvoid *)myusrhp, (ub4)0,
               OCI_ATTR_SESSION, myerrhp);
    INFO("Oracle connect successful!\n");
    return 0;
}
Beispiel #27
0
/**
 * test that blacktie correctly drives oracle xa
 * Precondition: - there is an active transaction (implies that that there is open XA connection)
 *
 * arguments:
 * op - 0 for insert 1 for select 2 for update and 3 for delete (CRUD)
 * arg - used in selects to hold the expected number of records
 * rbuf - used to report error strings (except in a successful select it holds the number of matching records)
 * bufsz - the length of rbuf
 */
int ora_access(test_req_t *req, test_req_t *resp)
{
	OCIStmt *stmthp;
	OCIError *errhp;
	OCIEnv *xaEnv;
	OCISvcCtx *svcCtx;
	sword status;

	btlogger_debug( "TxLog ora_access op=%c data=%s db=%s", req->op, req->data, req->db);

	/* opening an XA connection creates an environment and service context */
	xaEnv = (struct OCIEnv *) xaoEnv((text *) req->db) ;
	svcCtx = (struct OCISvcCtx *) xaoSvcCtx((text *) req->db);

	btlogger("TxLog ora_access env=%p svc=%p\n", xaEnv, svcCtx);

	if (xaEnv == NULL)
		return fatal("TxLog ORA:- Unable to obtain env!");

	if (svcCtx == NULL)
		return fatal("TxLog ORA:- Unable to obtain service context!");

	/* initialise OCI handles */
	if (OCI_SUCCESS != OCIHandleAlloc((dvoid *)xaEnv, (dvoid **)&errhp,
		OCI_HTYPE_ERROR, 0, (dvoid **)0))
		return fatal("ORA:- Unable to allocate statement handle");

	if (OCI_SUCCESS != OCIHandleAlloc((dvoid *)xaEnv, (dvoid **)&stmthp,
		OCI_HTYPE_STMT, 0, (dvoid **)0))
		return fatal("ORA:- Unable to allocate error handle");

	/* run the test */
	status = doWork(req->op, req->data, svcCtx, stmthp, errhp, resp);
	btlogger_debug( "TxLog %d: doWork %c returned: %s", status, req->op, resp->data);

//	return status;	// OCI_SUCCESS is 0
	return (status != OCI_SUCCESS);	// 0 means success
}
void TurnOnSqlTrace()
{
   OCIStmt *stmttracehp;
   static text *stmt_traceon   = (text *)"alter session set events '10046 trace name context forever, level 8'"; 

   CheckErr(errhp, OCIHandleAlloc(envhp, (dvoid **) &stmttracehp,
                                     OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0));

   CheckErr(errhp, OCIStmtPrepare(stmttracehp, errhp, (CONST text *) stmt_traceon,
                                     strlen((char *) stmt_traceon), OCI_NTV_SYNTAX, OCI_DEFAULT));

   CheckErr(errhp, OCIStmtExecute(svchp, stmttracehp, errhp, (ub4) 1, (ub4) 0,
                                     (CONST OCISnapshot *) 0, (OCISnapshot *) 0, OCI_DEFAULT));
}
Beispiel #29
0
char* db_select(int type, int keytype, int *num)
{
    int i;
    text dkeyword[SQL_MAXCOLUMN];
    ub4 col_keyword_len=0;
    char *words;
    OraText sentence[SQL_MAXLINE];
    char table[20];
    char *sql =  "select keyword from %s where type=%d";

    *num = db_getn(type, keytype);
    if (*num == -1 || *num == 0) {
        return NULL;
    }
    strcpy(table, (type == TYPE_KILL )? "kill_key" : "monitor_key");
    sprintf((char*)sentence, sql, table, keytype);

    checkerr(OCIHandleAlloc((dvoid *)myenvhp, (dvoid **)&mystmthp,
                            OCI_HTYPE_STMT, 0, 0), myerrhp);
    checkerr(OCIStmtPrepare(mystmthp, myerrhp, sentence, strlen((char*)sentence),
                            OCI_NTV_SYNTAX, OCI_DEFAULT), myerrhp);

    checkerr(OCIStmtExecute(mysvchp, mystmthp, myerrhp, 0, 0, 0, 0,
                            OCI_DEFAULT), myerrhp);

    if (OCIParamGet(mystmthp, OCI_HTYPE_STMT, myerrhp, (void **)&mypardp,
                    1) != OCI_SUCCESS) {
        return NULL;
    }
    checkerr(OCIAttrGet((dvoid*)mypardp, OCI_DTYPE_PARAM,
                        (dvoid*)&col_keyword_len, 0, OCI_ATTR_DATA_SIZE,
                        myerrhp), myerrhp);

    if ((status = OCIDefineByPos(mystmthp, &defkeywordp, myerrhp, 1,
                                 dkeyword, col_keyword_len + 1, SQLT_STR,
                                 0, 0, 0, OCI_DEFAULT))) {
        checkerr(status, myerrhp);
        return NULL;
    }
    if (!CALLOC(words, *num, SQL_MAXCOLUMN)) {
        return NULL;
    }
    for(i = 0; i < *num; i++) {
        checkerr(OCIStmtFetch2(mystmthp, myerrhp, 1, OCI_FETCH_NEXT,
                               i, OCI_DEFAULT), myerrhp);
        strcpy(words + SQL_MAXCOLUMN*i, (char*)dkeyword);
    }
    return words;
}
void OD_Create_cursor(sLONG_PTR *pResult, PackagePtr pParams)
{
	C_LONGINT Param1;
	C_LONGINT returnValue;
	
	Param1.fromParamAtIndex(pParams, 1);
	uint32_t sessionId = Param1.getIntValue();
	sessionInfo *session = _sessionGet(sessionId);
	
	if(session)
	{
		unsigned int i = 0;
		
		OCIStmt		*stmtp = 0;	
		OCIError	*errhp = 0;
		
		OCIEnv *envhp = session->envhp;
		
		OCIHandleAlloc((dvoid *)envhp, (dvoid **)&stmtp, OCI_HTYPE_STMT,	0, 0);	
		OCIHandleAlloc((dvoid *)envhp, (dvoid **)&errhp, OCI_HTYPE_ERROR,	0, 0);
		
		_cursorCreate(&i, sessionId, stmtp, errhp);
		returnValue.setIntValue(i);	
		
		if(!i)
		{
			OCIHandleFree(stmtp, OCI_HTYPE_STMT);
			OCIHandleFree(errhp, OCI_HTYPE_ERROR);
			
			returnValue.setIntValue(-1);	
		}
		
	}
	
	returnValue.setReturn(pResult);	
}