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;
}
void OWStatement::BindArray( void* pData, long nSize )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) pData,
(sb4) nSize * sizeof(double),
(ub2) SQLT_BIN,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ), hError );
CheckError( OCIBindArrayOfStruct(
hBind,
hError,
(ub4) nSize * sizeof(double),
(ub4) 0,
(ub4) 0,
(ub4) 0), hError );
}
static void
trace(plruby_context_t *ctx, int level, const char *fmt, ...)
{
OCIStmt *stmtp = NULL;
OCIBind *bindp = NULL;
OCIInd ind = 0;
char msg[2000];
ub2 msglen;
const char *stmt = "BEGIN DBMS_OUTPUT.PUT_LINE(:1); END;";
sword rv;
va_list ap;
if (level > trace_level) {
return;
}
va_start(ap, fmt);
vsnprintf(msg, sizeof(msg), fmt, ap);
va_end(ap);
msg[sizeof(msg) - 1] = '\0';
msglen = strlen(msg);
rv = OCIStmtPrepare2(ctx->svchp, &stmtp, ctx->errhp, (OraText*)stmt, strlen(stmt), NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT);
if (rv != OCI_SUCCESS) {
return;
}
OCIBindByPos(stmtp, &bindp, ctx->errhp, 1, (OraText*)msg, msglen, SQLT_CHR, &ind, &msglen, NULL, 0, NULL, OCI_DEFAULT);
OCIStmtExecute(ctx->svchp, stmtp, ctx->errhp, 1, 0, NULL, NULL, OCI_DEFAULT);
OCIStmtRelease(stmtp, ctx->errhp, NULL, 0, OCI_DEFAULT);
}
static sword zbx_oracle_bind_parameter(ub4 position, void *buffer, sb4 buffer_sz, ub2 dty)
{
OCIBind *bindhp = NULL;
return OCIBindByPos(oracle.stmthp, &bindhp, oracle.errhp, position, buffer, buffer_sz, dty,
0, 0, 0, 0, 0, (ub4)OCI_DEFAULT);
}
void OWStatement::Bind( OCIArray** pphData, OCIType* type )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) 0,
(sb4) 0,
(ub2) SQLT_NTY,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ),
hError );
CheckError( OCIBindObject(
hBind,
hError,
type,
(dvoid **)pphData,
(ub4 *)0,
(dvoid **)0,
(ub4 *)0 ),
hError);
}
void OWStatement::Bind( sdo_geometry** pphData )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) NULL,
(sb4) 0,
(ub2) SQLT_NTY,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) 0,
(ub4) 0,
(ub4) OCI_DEFAULT ),
hError );
CheckError( OCIBindObject(
hBind,
hError,
poConnection->hGeometryTDO,
(dvoid**) pphData,
(ub4*) 0,
(dvoid**) 0,
(ub4*) 0),
hError );
}
void OraclePreparedStatement_setString(T P, int parameterIndex, const char *x) {
TEST_INDEX
P->params[i].type.string = x;
P->params[i].length = x ? strlen(x) : 0;
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, (char *)P->params[i].type.string,
(int)P->params[i].length, SQLT_CHR, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
void OraclePreparedStatement_setDouble(T P, int parameterIndex, double x) {
TEST_INDEX
P->params[i].type.real = x;
P->params[i].length = sizeof(x);
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, &P->params[i].type.real,
(int)P->params[i].length, SQLT_FLT, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
void OraclePreparedStatement_setBlob(T P, int parameterIndex, const void *x, int size) {
TEST_INDEX
P->params[i].type.blob = x;
P->params[i].length = (x) ? size : 0;
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, (void *)P->params[i].type.blob,
(int)P->params[i].length, SQLT_LNG, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
void OraclePreparedStatement_setTimestamp(T P, int parameterIndex, time_t time) {
assert(P);
struct tm ts = {.tm_isdst = -1};
ub4 valid;
int i = checkAndSetParameterIndex(parameterIndex, P->paramCount);
P->lastError = OCIDescriptorAlloc((dvoid *)P->env, (dvoid **) &(P->params[i].type.date),
(ub4) OCI_DTYPE_TIMESTAMP,
(size_t) 0, (dvoid **) 0);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
gmtime_r(&time, &ts);
OCIDateTimeConstruct(P->usr,
P->err,
P->params[i].type.date, //OCIDateTime *datetime,
ts.tm_year+1900, ts.tm_mon+1, ts.tm_mday, ts.tm_hour, ts.tm_min, ts.tm_sec, 0/*fsec*/,
(OraText*)0, 0);
if (OCI_SUCCESS != OCIDateTimeCheck(P->usr, P->err, P->params[i].type.date, &valid) || valid != 0)
{
THROW(SQLException, "Invalid date/time value");
}
P->params[i].length = sizeof(OCIDateTime *);
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, &P->params[i].type.date,
P->params[i].length, SQLT_TIMESTAMP, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
void OraclePreparedStatement_setInt(T P, int parameterIndex, int x) {
assert(P);
int i = checkAndSetParameterIndex(parameterIndex, P->paramCount);
P->params[i].type.integer = x;
P->params[i].length = sizeof(x);
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, &P->params[i].type.integer,
(int)P->params[i].length, SQLT_INT, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
where empno = :id";
void update_salary(OCISvcCtx *svchp, OCIError *errhp, thdata *pthdata)
{
OCIBind *bndp1, *bndp2;
OCIStmt *stmthp;
int i;
if (verbose_flag)
printf ("updating salaries \n");
checkerr(errhp,
OCIStmtPrepare2 (svchp, &stmthp, /* returned stmt handle */
errhp, /* error handle */
(const OraText *) MY_DML, /* input statement text*/
strlen((char *) MY_DML), /* length of text */
NULL, 0, /* tagging parameters: optional */
OCI_NTV_SYNTAX, OCI_DEFAULT));
/* do parameter bindings */
checkerr(errhp, OCIBindByPos(stmthp, &bndp1, errhp, 1,
(void *) (pthdata->salaries),
(sword) sizeof(*(pthdata->salaries)),
SQLT_INT, (void *) NULL, (ub2 *) NULL,
(ub2 *) NULL, 0, (ub4 *) NULL, OCI_DEFAULT));
checkerr(errhp, OCIBindByPos(stmthp, &bndp2, errhp, 2,
(void *) (pthdata->id),
(sword) sizeof(*(pthdata->id)), SQLT_INT,
(void *) NULL, (ub2 *) NULL, (ub2 *) NULL, 0,
(ub4 *) NULL, OCI_DEFAULT));
/* execute the statement and commit */
checkerr(errhp, OCIStmtExecute(svchp, stmthp, errhp, update_num, 0,
(OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_COMMIT_ON_SUCCESS));
/* release the statement handle */
checkerr(errhp, OCIStmtRelease(stmthp, errhp,
(OraText *) NULL, 0, OCI_DEFAULT));
if (verbose_flag)
printf("updated salaries successfully\n");
}
void OraclePreparedStatement_setLLong(T P, int parameterIndex, long long int x) {
TEST_INDEX
P->params[i].length = sizeof(P->params[i].type.number);
P->lastError = OCINumberFromInt(P->err, &x, sizeof(x), OCI_NUMBER_SIGNED, &P->params[i].type.number);
if (P->lastError != OCI_SUCCESS)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
P->lastError = OCIBindByPos(P->stmt, &P->params[i].bind, P->err, parameterIndex, &P->params[i].type.number,
(int)P->params[i].length, SQLT_VNU, 0, 0, 0, 0, 0, OCI_DEFAULT);
if (P->lastError != OCI_SUCCESS && P->lastError != OCI_SUCCESS_WITH_INFO)
THROW(SQLException, "%s", OraclePreparedStatement_getLastError(P->lastError, P->err));
}
/*
=begin
--- OCIStmt#bindByPos(position, type [, length [, mode]])
define the datatype of the bind variable by posision.
:position
the position of the bind variable.
:type
the type of the bind variable.
((|String|)), ((|Fixnum|)), ((|Integer|)), ((|Float|)), ((|Time|)),
((<OraDate>)), ((<OraNumber>)), or ((|OCI_TYPECODE_RAW|))
:length
When the 2nd argument is
* ((|String|)) or ((|OCI_TYPECODE_RAW|)),
the max length of fetched data.
* otherwise,
its value is ignored.
:mode
((|OCI_DEFAULT|)), or ((|OCI_DATA_AT_EXEC|)). But now available value is
((|OCI_DEFAULT|)) only. Default value is ((|OCI_DEFAULT|))
:return value
newly created ((<bind handle|OCIBind>))
correspond native OCI function: ((|OCIBindByPos|))
=end
*/
static VALUE oci8_bind_by_pos(int argc, VALUE *argv, VALUE self)
{
VALUE vposition;
VALUE vtype;
VALUE vlength;
VALUE vmode;
oci8_handle_t *h;
ub4 position;
oci8_bind_handle_t *bh;
ub2 dty;
ub4 mode;
dvoid *indp;
ub2 *rlenp;
dvoid *valuep;
OCIBind *bindhp = NULL;
sword status;
VALUE hash;
VALUE obj;
rb_scan_args(argc, argv, "22", &vposition, &vtype, &vlength, &vmode);
Get_Handle(self, h); /* 0 */
position = NUM2INT(vposition); /* 1 */
check_bind_type(OCI_HTYPE_BIND, h, vtype, vlength, &bh, &dty); /* 2, 3 */
Get_Int_With_Default(argc, 4, vmode, mode, OCI_DEFAULT); /* 4 */
if (mode & OCI_DATA_AT_EXEC) {
indp = NULL;
rlenp = NULL;
} else {
indp = &(bh->ind);
rlenp = (bh->bind_type == BIND_STRING) ? NULL : &bh->rlen;
}
valuep = &bh->value;
status = OCIBindByPos(h->hp, &bindhp, h->errhp, position, valuep, bh->value_sz, dty, indp, rlenp, 0, 0, 0, mode);
if (status != OCI_SUCCESS) {
oci8_unlink((oci8_handle_t *)bh);
bh->type = 0;
oci8_raise(h->errhp, status, h->hp);
}
bh->type = OCI_HTYPE_BIND;
bh->hp = bindhp;
bh->errhp = h->errhp;
obj = bh->self;
hash = rb_ivar_get(self, oci8_id_bind_hash);
if (hash == Qnil) {
hash = rb_hash_new();
rb_ivar_set(self, oci8_id_bind_hash, hash);
}
rb_hash_aset(hash, vposition, obj);
return obj;
}
/* 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;
}
}
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;
}
void OWStatement::Bind( double* pnData )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) pnData,
(sb4) sizeof(double),
(ub2) SQLT_BDOUBLE,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ),
hError );
}
void OWStatement::Bind( char* pData, long nData )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) pData,
(sb4) nData,
(ub2) SQLT_LBI,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ),
hError );
}
void OWStatement::Bind( OCILobLocator** pphLocator )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) pphLocator,
(sb4) -1,
(ub2) SQLT_CLOB,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ),
hError );
}
void OWStatement::Bind( char* pszData, int nSize )
{
OCIBind* hBind = NULL;
nNextBnd++;
CheckError( OCIBindByPos(
hStmt,
&hBind,
hError,
(ub4) nNextBnd,
(dvoid*) pszData,
(sb4) nSize,
(ub2) SQLT_STR,
(void*) NULL,
(ub2*) NULL,
(ub2*) NULL,
(ub4) NULL,
(ub4) NULL,
(ub4) OCI_DEFAULT ),
hError );
}
/* 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;
}
GSQLCursorState
oracle_cursor_open_bind (GSQLCursor *cursor, GList *args)
{
GSQL_TRACE_FUNC;
GSQLEOracleCursor *spec_cursor;
GSQLEOracleSession *spec_session;
GSQLEOracleVariable *spec_var;
GSQLVariable *var;
GList *vlist = args;
GType vtype;
guint n, var_count=0;
sword ret;
OCIParam *param;
static OCIBind *bindhp = 0;
unsigned char op[2000];
gint i;
gchar buffer[GSQL_MESSAGE_LEN];
g_return_val_if_fail (GSQL_IS_CURSOR (cursor), GSQL_CURSOR_STATE_ERROR);
spec_session = (GSQLEOracleSession *) cursor->session->spec;
spec_cursor = g_malloc0 (sizeof (GSQLEOracleCursor));
cursor->spec = spec_cursor;
ret = OCIHandleAlloc ((dvoid *)(spec_session->envhp),
(dvoid **)&(spec_cursor->errhp),
OCI_HTYPE_ERROR, 0, (dvoid **) 0);
if (ret == OCI_ERROR)
{
GSQL_DEBUG("oracle_cursor_open: OCIHandleAlloc (allocate an error handle)... failed");
cursor->spec = NULL;
g_free (spec_cursor);
return GSQL_CURSOR_STATE_ERROR;
}
if (!oracle_sql_prepare (cursor, cursor->sql))
{
OCIHandleFree ((dvoid *)spec_cursor->errhp, OCI_HTYPE_ERROR);
cursor->spec = NULL;
g_free (spec_cursor);
return GSQL_CURSOR_STATE_ERROR;
}
n = 0;
while (vlist)
{
vtype = (GType) vlist->data;
vlist = g_list_next (vlist);
switch (vtype)
{
case G_TYPE_STRING:
case G_TYPE_POINTER:
ret = OCIBindByPos (spec_cursor->statement, &bindhp, spec_cursor->errhp, (ub4) n+1,
(dvoid *) vlist->data, (sb4)strlen(vlist->data)+1, (ub2) SQLT_STR,
(dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
(ub4) OCI_DEFAULT);
break;
case G_TYPE_INT:
case G_TYPE_UINT:
GSQL_FIXME;
break;
case G_TYPE_UINT64:
case G_TYPE_INT64:
GSQL_FIXME;
break;
case G_TYPE_DOUBLE:
GSQL_FIXME;
break;
};
vlist = g_list_next (vlist);
n++;
}
if (!oracle_sql_exec (cursor))
{
OCIHandleFree ((dvoid *)spec_cursor->errhp, OCI_HTYPE_ERROR);
cursor->spec = NULL;
g_free (spec_cursor);
return GSQL_CURSOR_STATE_ERROR;
}
ret = OCIAttrGet (spec_cursor->statement, OCI_HTYPE_STMT, (dvoid*) &(var_count), 0,
OCI_ATTR_PARAM_COUNT, spec_cursor->errhp);
if (oracle_check_error (cursor, ret))
{
OCIHandleFree ((dvoid *)spec_cursor->errhp, OCI_HTYPE_ERROR);
cursor->spec = NULL;
g_free (spec_cursor);
return GSQL_CURSOR_STATE_ERROR;
}
for (i = 0; i < var_count; i++)
{
ret = OCIParamGet (spec_cursor->statement, OCI_HTYPE_STMT,
spec_cursor->errhp, (void**) ¶m, i+1);
if (oracle_check_error (cursor, ret))
{
g_free (spec_cursor);
return GSQL_CURSOR_STATE_ERROR;
};
var = gsql_variable_new ();
oracle_variable_init (cursor, var, param, i+1);
cursor->var_list = g_list_append (cursor->var_list, var);
OCIDescriptorFree (param, OCI_DTYPE_PARAM);
}
return GSQL_CURSOR_STATE_OPEN;
}
/*
* 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 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;
}
static void
oracle_dbms_output (GSQLCursor *cursor)
{
GSQL_TRACE_FUNC;
GSQLEOracleSession *session;
GSQLWorkspace *workspace;
OCIBind *bind_p1 = NULL, *bind_p2 = NULL;
OCIStmt *sth = NULL;
sb2 ind = OCI_IND_NULL;
OCIError *errhp;
const gchar *sql = "begin dbms_output.get_line (line=>:p1, status=>:p2); end;";
gchar *mess = NULL;
// FIXME: use gconf
#define DBMS_OUTPUT_BUFFER 2048
gchar p1_value[DBMS_OUTPUT_BUFFER];
gint p2_value = 0, ret;
session = (GSQLEOracleSession *) cursor->session->spec;
workspace = gsql_session_get_workspace (cursor->session);
OCIHandleAlloc ((dvoid *)(session->envhp),
(dvoid **)&(errhp),
OCI_HTYPE_ERROR, 0, (dvoid **) 0);
OCIStmtPrepare2(session->svchp,
&sth,
errhp,
(text *) sql,
strlen(sql),
NULL, 0,
OCI_NTV_SYNTAX,
OCI_DEFAULT);
OCIBindByPos (sth, &bind_p1, errhp, (ub4) 1,
(dvoid *) p1_value, (sb4) DBMS_OUTPUT_BUFFER,
(ub2) SQLT_STR,
(dvoid *) &ind, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
(ub4) OCI_DEFAULT);
OCIBindByPos (sth, &bind_p2, errhp, (ub4) 2,
(dvoid *) &p2_value, (sb4) sizeof(p2_value),
(ub2) SQLT_INT,
(dvoid *) &ind, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
(ub4) OCI_DEFAULT);
while (p2_value != 1)
{
ret = OCIStmtExecute(session->svchp, sth,
errhp, 1, 0, 0, 0, OCI_DEFAULT);
if (ret != OCI_SUCCESS)
{
GSQL_DEBUG ("Couldn't get dbms output: %s",
oracle_get_error_string (errhp));
break;
}
if (g_utf8_strlen (p1_value, DBMS_OUTPUT_BUFFER) > 0)
{
mess = gsql_utils_escape_string (p1_value);
GSQL_DEBUG ("DBMS_OUTPUT: %s", mess);
gsql_message_add (workspace, GSQL_MESSAGE_OUTPUT, mess);
g_free (mess);
}
}
OCIHandleFree((dvoid *)sth, (ub4)OCI_HTYPE_STMT);
OCIHandleFree((dvoid *)errhp, (ub4)OCI_HTYPE_ERROR);
}
/*
* success,err = statement:execute(...)
*/
int statement_execute(lua_State *L) {
int n = lua_gettop(L);
statement_t *statement = (statement_t *)luaL_checkudata(L, 1, DBD_ORACLE_STATEMENT);
int p;
int errflag = 0;
const char *errstr = NULL;
int num_columns;
int rc;
char errbuf[100];
int errcode;
ub2 type;
if (!statement->stmt) {
lua_pushboolean(L, 0);
lua_pushstring(L, DBI_ERR_EXECUTE_INVALID);
return 2;
}
for (p = 2; p <= n; p++) {
int i = p - 1;
int type = lua_type(L, p);
char err[64];
const char *value;
OCIBind *bnd = (OCIBind *)0;
switch(type) {
case LUA_TNIL:
errflag = OCIBindByPos(
statement->stmt,
&bnd,
statement->conn->err,
i,
NULL,
0,
SQLT_CHR,
(dvoid *)0,
(ub2 *)0,
(ub2 *)0,
(ub4)0,
(ub4 *)0,
OCI_DEFAULT);
break;
case LUA_TNUMBER:
case LUA_TSTRING:
case LUA_TBOOLEAN:
value = lua_tostring(L, p);
errflag = OCIBindByPos(
statement->stmt,
&bnd,
statement->conn->err,
i,
value,
strlen(value),
SQLT_CHR,
(dvoid *)0,
(ub2 *)0,
(ub2 *)0,
(ub4)0,
(ub4 *)0,
(ub4)OCI_DEFAULT);
break;
default:
/*
* Unknown/unsupported value type
*/
errflag = 1;
snprintf(err, sizeof(err)-1, DBI_ERR_BINDING_TYPE_ERR, lua_typename(L, type));
errstr = err;
}
if (errflag)
break;
}
if (errflag) {
lua_pushboolean(L, 0);
if (errstr)
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, errstr);
else {
OCIErrorGet((dvoid *)statement->conn->err, (ub4) 1, (text *) NULL, &errcode, errbuf, (ub4) sizeof(errbuf), OCI_HTYPE_ERROR);
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, errbuf);
}
return 2;
}
/*
* statement type
*/
rc = OCIAttrGet(
(dvoid *)statement->stmt,
(ub4)OCI_HTYPE_STMT,
(dvoid *)&type,
(ub4 *)0,
(ub4)OCI_ATTR_STMT_TYPE,
statement->conn->err
);
if (rc) {
OCIErrorGet((dvoid *)statement->conn->err, (ub4) 1, (text *) NULL, &errcode, errbuf, (ub4) sizeof(errbuf), OCI_HTYPE_ERROR);
lua_pushboolean(L, 0);
lua_pushfstring(L, "Error getting type: %s", errbuf);
return 2;
}
/*
* execute statement
*/
rc = OCIStmtExecute(
statement->conn->svc,
statement->stmt,
statement->conn->err,
type == OCI_STMT_SELECT ? 0 : 1,
(ub4)0,
(CONST OCISnapshot *)NULL,
(OCISnapshot *)NULL,
statement->conn->autocommit ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT
);
if (rc) {
OCIErrorGet((dvoid *)statement->conn->err, (ub4) 1, (text *) NULL, &errcode, errbuf, (ub4) sizeof(errbuf), OCI_HTYPE_ERROR);
lua_pushboolean(L, 0);
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, errbuf);
return 2;
}
/*
* get number of columns
*/
rc = OCIAttrGet(
(dvoid *)statement->stmt,
(ub4)OCI_HTYPE_STMT,
(dvoid *)&num_columns,
(ub4 *)0,
(ub4)OCI_ATTR_PARAM_COUNT,
statement->conn->err
);
if (rc) {
OCIErrorGet((dvoid *)statement->conn->err, (ub4) 1, (text *) NULL, &errcode, errbuf, (ub4) sizeof(errbuf), OCI_HTYPE_ERROR);
lua_pushboolean(L, 0);
lua_pushfstring(L, DBI_ERR_BINDING_PARAMS, errbuf);
return 2;
}
statement->num_columns = num_columns;
lua_pushboolean(L, 1);
return 1;
}
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;
}
INTF_RET oci_exec_sql(const void *conn_handle, unsigned long & stmt_handle, const unsigned char * query_str, int query_str_len, inp_t *params_head, void * column_list)
{
function_success = SUCCESS;
#if DEBUG < DBG_5
fprintf(fp_log, "Executing \"%.*s;\"\n", query_str_len, query_str);
#endif
OCISvcCtx *svchp = (OCISvcCtx *)conn_handle;
OCIStmt *stmthp = NULL;
stmt_handle = 0;
/* Get a prepared statement handle */
checkerr(errhp, OCIStmtPrepare2(svchp,
&stmthp, /* returned statement handle */
errhp, /* error handle */
(OraText *) query_str, /* the statement text */
query_str_len, /* length of the text */
NULL, 0, /* tagging parameters: optional */
OCI_NTV_SYNTAX, OCI_DEFAULT));
if(function_success != SUCCESS) return function_success;
/* Bind variables */
ub2 type = SQLT_INT;
int idx = 1;
for(inp_t *param = params_head; param != NULL; param = param->next) {
switch (param->dty) {
case NUMBER:
type = SQLT_INT;
break;
case STRING:
type = SQLT_STR;
break;
}
param->bndp = NULL;
checkerr(errhp, OCIBindByPos(stmthp, (OCIBind **)&(param->bndp), errhp, idx,
(dvoid *) param->valuep, (sword) param->value_sz, type,
(dvoid *) 0, (ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0, OCI_DEFAULT));
if(function_success != SUCCESS) return function_success;
idx++;
}
ub4 stmt_typ = OCI_STMT_SELECT;
ub4 itrs = 0;
checkerr(errhp, OCIAttrGet((dvoid*) stmthp, (ub4) OCI_HTYPE_STMT,
(dvoid*) &stmt_typ, (ub4 *)NULL, (ub4)OCI_ATTR_STMT_TYPE, errhp));
if(function_success != SUCCESS) return function_success;
if(stmt_typ != OCI_STMT_SELECT)
itrs = 1;
/* execute the statement and commit */
checkerr(errhp, OCIStmtExecute(svchp, stmthp, errhp, itrs, 0,
(OCISnapshot *)NULL, (OCISnapshot *)NULL,
OCI_COMMIT_ON_SUCCESS));
if(function_success != SUCCESS) return function_success;
if(stmt_typ == OCI_STMT_SELECT) {
OCIParam *mypard;
num_cols = 1;
sb4 parm_status;
/* Request a parameter descriptor for position 1 in the select-list */
parm_status = OCIParamGet(stmthp, OCI_HTYPE_STMT, errhp, (dvoid **)&mypard,
(ub4) num_cols);
checkerr(errhp, parm_status);
if(function_success != SUCCESS) return function_success;
/* Loop only if a descriptor was successfully retrieved for
* current position, starting at 1
*/
text *col_name;
ub4 len = 0;
char * data_type = NULL;
if (columns != NULL)
free(columns);
columns = NULL;
while (parm_status == OCI_SUCCESS) {
columns = (column_info *)realloc(columns, num_cols * sizeof(column_info));
column_info * cur_clm = &(columns[num_cols-1]);
/* Retrieve the data type attribute */
len = 0;
checkerr(errhp, OCIAttrGet((dvoid*) mypard, (ub4) OCI_DTYPE_PARAM,
(dvoid*) &len, (ub4 *)0, (ub4)OCI_ATTR_DATA_TYPE,
errhp));
if(function_success != SUCCESS) return function_success;
cur_clm->dtype = len;
switch (len) {
case SQLT_NUM:
case SQLT_VNU:
case SQLT_LNG:
data_type = (char*)"number";
break;
case SQLT_AVC:
case SQLT_AFC:
case SQLT_CHR:
case SQLT_STR:
case SQLT_VCS:
data_type = (char*)"string";
break;
case SQLT_INT:
case SQLT_UIN:
data_type = (char*)"integer";
break;
case SQLT_DAT:
data_type = (char*)"date";
break;
case SQLT_FLT:
data_type = (char*)"double";
break;
default:
data_type = (char*)"undefined";
break;
}
/* Retrieve the data size attribute */
len = 0;
checkerr(errhp, OCIAttrGet((dvoid*) mypard, (ub4) OCI_DTYPE_PARAM,
(dvoid*) &len, (ub4 *)0, (ub4)OCI_ATTR_DATA_SIZE,
errhp));
if(function_success != SUCCESS) return function_success;
cur_clm->dlen = len;
/* Retrieve the column name attribute */
len = 0;
checkerr(errhp, OCIAttrGet((dvoid*) mypard, (ub4) OCI_DTYPE_PARAM,
(dvoid**) &col_name, (ub4 *) &len, (ub4) OCI_ATTR_NAME,
errhp));
if(function_success != SUCCESS) return function_success;
char * column_name = new char[len+1];
sprintf_s(column_name, len+1, "%.*s", len, col_name);
append_coldef_to_list(column_name, data_type, cur_clm->dlen, column_list);
delete column_name;
col_name = NULL;
/* Increment counter and get next descriptor, if there is one */
if(OCI_SUCCESS != OCIDescriptorFree(mypard, OCI_DTYPE_PARAM))
return FAILURE;
num_cols++;
parm_status = OCIParamGet(stmthp, OCI_HTYPE_STMT, errhp, (dvoid **)&mypard,
(ub4) num_cols);
}
--num_cols;
if(function_success != SUCCESS)
return function_success;
REMOTE_LOG("Port: Returning Columns");
stmt_handle = (unsigned long)stmthp;
} else {
if(stmthp != NULL) {
checkerr(errhp, OCIStmtRelease(stmthp, errhp, NULL, 0, OCI_DEFAULT));
if(function_success != SUCCESS) return function_success;
}
REMOTE_LOG("Port: Executed non-select statement!");
}
return function_success;
}
