int FC_FUNC_(oraclesim_getanavol, ORACLESIM_GETANAVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr, int *namelen,
int *ostatid, double *olon, double *olat, float *oqs, float *oqp,
char *oname, char *onet, float *rmiss, double *dmiss) {
OracleDbConnection *dbconnid = *fdbconnid;
int i, ret;
sword status;
/* definisco l'uscita */
anadefine(dbconnid, ostatid, olon, olat, oqs, oqp, oname, onet, *namelen);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (olon[i] < -999.) olon[i] = *dmiss;
if (olat[i] < -999.) olat[i] = *dmiss;
if (oqs[i] < -9999.) oqs[i] = *rmiss;
if (oqp[i] < -9999.) oqp[i] = *rmiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
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;
}
int FC_FUNC_(oraclesim_getdatavol, ORACLESIM_GETDATAVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr,
char *odate, int *ostatid, int *ovarid,
float *ovalp, float *ovala, char *ovalc, char *oflag, float *rmiss) {
OracleDbConnection *dbconnid = *fdbconnid;
sword status;
int i, ret;
/* definisco l'uscita */
datadefine(dbconnid, odate, DATELEN, ostatid, ovarid, ovalp, ovala, ovalc, oflag, CVALLEN, FLAGLEN);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (ovalp[i] > 1.0E+14) ovalp[i] = *rmiss;
if (ovala[i] > 1.0E+14) ovala[i] = *rmiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
gint
oracle_cursor_fetch(GSQLCursor * cursor, gint rows)
{
GSQL_TRACE_FUNC;
sword ret;
gint fetched;
GSQLEOracleCursor *cursor_spec;
g_return_if_fail (GSQL_IS_CURSOR (cursor));
cursor_spec = cursor->spec;
oracle_variable_clear (cursor);
ret = OCIStmtFetch2 (cursor_spec->statement,
cursor_spec->errhp,
1,
OCI_FETCH_NEXT,
(sb4) 0,
OCI_DEFAULT);
if (oracle_check_error (cursor, ret))
return 0;
fetched = 0;
ret = OCIAttrGet (cursor_spec->statement, OCI_HTYPE_STMT,
(void *) &fetched, (uint *) 0,
OCI_ATTR_ROWS_FETCHED, cursor_spec->errhp);
GSQL_DEBUG ("ORACLE Fetched [%d]", fetched);
return fetched;
}
int countrows(OracleDbConnection *dbconnid) {
int nr;
sword status;
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Vado all'ultima riga e chiedo dove sono */
if ((status=OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_LAST, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, &nr, 0,
OCI_ATTR_CURRENT_POSITION, dbconnid->errhp))
!= OCI_SUCCESS) return -1;
return nr;
}
int gettab(OracleDbConnection *dbconnid, int *var, int nvar, int *net) {
sword status;
checkerr(dbconnid,
OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) tabquery,
(ub4) strlen(tabquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
/* checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":var",
-1, (dvoid *) var,
(sword) sizeof(*var), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT)); */
checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":net",
-1, (dvoid *) net,
(sword) sizeof(*net), SQLT_INT, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid,
OCIDefineByPos(dbconnid->stmthp, &dbconnid->defn1p,
dbconnid->errhp, 1,
(dvoid *) dbconnid->table, TABLEN, SQLT_STR,
(dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, OCI_DEFAULT));
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Prendo la prima riga di dati */
if ((status = OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_NEXT, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status == OCI_NO_DATA) {
return -1;
} else {
checkerr(dbconnid, status);
return -1;
}
}
return 0;
}
int FC_FUNC_(oraclesim_getnet, ORACLESIM_GETNET)
(OracleDbConnection **fdbconnid, const char *netdesc) {
OracleDbConnection *dbconnid = *fdbconnid;
sword status;
int onetid;
/* Preparo l'estrazione per ottenere il numero della rete dal nome */
checkerr(dbconnid,
OCIStmtPrepare(dbconnid->stmthp, dbconnid->errhp,
(text *) netquery,
(ub4) strlen(netquery),
(ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT));
checkerr(dbconnid,
OCIBindByName(dbconnid->stmthp, &dbconnid->bnd1p,
dbconnid->errhp, (text *) ":netdesc",
-1, (dvoid *) netdesc,
(sword) strlen(netdesc)+1, SQLT_STR, (dvoid *) NULL,
(ub2 *) 0, (ub2 *) 0, (ub4) 0, (ub4 *) 0,
OCI_DEFAULT));
checkerr(dbconnid,
OCIDefineByPos(dbconnid->stmthp, &dbconnid->defn1p,
dbconnid->errhp, 1,
(dvoid *) &onetid, sizeof(onetid), SQLT_INT,
(dvoid *) 0,
(ub2 *) 0, (ub2 *) 0, OCI_DEFAULT));
/* Lancio l'estrazione */
if ((status = OCIStmtExecute(dbconnid->svchp, dbconnid->stmthp, dbconnid->errhp,
(ub4) 0, (ub4) 0,
(CONST OCISnapshot *) NULL, (OCISnapshot *) NULL,
OCI_STMT_SCROLLABLE_READONLY)) != OCI_SUCCESS) {
if (status != OCI_NO_DATA) {
checkerr(dbconnid, status);
return -1;
}
}
/* Prendo la prima riga di dati */
if ((status = OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp, (ub4) 1,
(ub2) OCI_FETCH_NEXT, (sb4) 0,
(ub4) OCI_DEFAULT)) != OCI_SUCCESS) {
if (status == OCI_NO_DATA) {
return 0;
} else {
checkerr(dbconnid, status);
return -1;
}
}
return onetid;
}
static GdaRow *
fetch_next_oracle_row (GdaOracleRecordset *model, G_GNUC_UNUSED gboolean do_store, GError **error)
{
int result;
GdaRow *prow = NULL;
GdaOraclePStmt *ps = GDA_ORACLE_PSTMT (((GdaDataSelect*)model)->prep_stmt);
OracleConnectionData *cdata;
GdaConnection *cnc;
cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
if (!cdata)
return NULL;
/* fetch row */
if (cdata->major_version > 9)
result = OCIStmtFetch2 (ps->hstmt,
cdata->herr,
(ub4) 1,
(ub2) OCI_FETCH_NEXT,
(sb4) 1,
(ub4) OCI_DEFAULT);
else
result = OCIStmtFetch (ps->hstmt,
cdata->herr,
(ub4) 1,
(ub2) OCI_FETCH_NEXT,
(ub4) OCI_DEFAULT);
if (result == OCI_NO_DATA) {
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
return NULL;
}
else {
GdaConnectionEvent *event;
if ((event = gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not fetch next row")))) {
/* set @error */
g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", gda_connection_event_get_description (event));
return NULL;
}
}
prow = new_row ((GdaDataSelect*) model, cnc, ps);
gda_data_select_take_row ((GdaDataSelect*) model, prow, model->priv->next_row_num);
model->priv->next_row_num ++;
return prow;
}
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;
}
int FC_FUNC_(oraclesim_getvarvol, ORACLESIM_GETVARVOL)
(OracleDbConnection **fdbconnid, int *nr, int *vnr, int *oidentnr,
int *olt1, int *ol1, int *olt2, int *ol2,
int *opind, int *op1, int *op2, int *imiss) {
OracleDbConnection *dbconnid = *fdbconnid;
int i, ret;
sword status;
/* definisco l'uscita */
vardefine(dbconnid, oidentnr, olt1, ol1, olt2, ol2, opind, op1, op2);
status=checkerr(dbconnid, OCIStmtFetch2(dbconnid->stmthp, dbconnid->errhp,
(ub4) *nr, OCI_FETCH_FIRST, (sb4) 0,
(ub4) OCI_DEFAULT));
if (status == OCI_SUCCESS || status == OCI_NO_DATA) {
if (checkerr(dbconnid, OCIAttrGet(dbconnid->stmthp, OCI_HTYPE_STMT, vnr, 0,
OCI_ATTR_ROW_COUNT, dbconnid->errhp))
== OCI_SUCCESS) {
for (i=0; i<*vnr; i++) { /* inserisco i dati mancanti stile libsim */
if (olt1[i] == -999) {
olt1[i] = *imiss;
ol1[i] = *imiss;
} else {
if (ol1[i] == -999) ol1[i] = *imiss;
}
if (olt2[i] == 0 || olt2[i] == -999) { /* in Oracle qui c'e` 0 al posto di mancante */
olt2[i] = *imiss;
ol2[i] = *imiss;
} else {
if (ol2[i] == -999) ol2[i] = *imiss;
}
if (opind[i] == -999) opind[i] = *imiss;
if (op1[i] == -999) op1[i] = *imiss;
if (op2[i] == -999) op2[i] = *imiss;
}
} else {
*vnr = 0;
}
ret = 0;
} else {
*vnr = 0;
ret = 2;
}
return ret;
}
sword _checkNumberOfRecordsToFetch(ORACLE_SQL_CURSOR *cursor)
{
sword err = 0;
if(cursor->rowCount != 0)
{
//not first call after sql execution
sword status = 0;
status = OCIStmtFetch2(cursor->stmtp, cursor->errhp, cursor->itemCount, OCI_DEFAULT, 0, OCI_DEFAULT);
//http://docs.oracle.com/cd/A97630_01/appdev.920/a96584/oci16ms4.htm
switch (status)
{
case OCI_NO_DATA:
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowsFetched, 0, OCI_ATTR_ROWS_FETCHED, cursor->errhp);
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowCount, 0, OCI_ATTR_ROW_COUNT, cursor->errhp);
cursor->isEndOfSelection = true;
break;
case 0:
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowsFetched, 0, OCI_ATTR_ROWS_FETCHED, cursor->errhp);
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowCount, 0, OCI_ATTR_ROW_COUNT, cursor->errhp);
break;
default:
err = -1;//used as return code for error
cursor->isEndOfSelection = true;
break;//error
}
}else{
//first call after sql execution
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowsFetched, 0, OCI_ATTR_ROWS_FETCHED, cursor->errhp);
OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, &cursor->rowCount, 0, OCI_ATTR_ROW_COUNT, cursor->errhp);
}
return err;
}
static int oci_stmt_fetch(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset) /* {{{ */
{
#if HAVE_OCISTMTFETCH2
ub4 ociori;
#endif
pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
#if HAVE_OCISTMTFETCH2
switch (ori) {
case PDO_FETCH_ORI_NEXT: ociori = OCI_FETCH_NEXT; break;
case PDO_FETCH_ORI_PRIOR: ociori = OCI_FETCH_PRIOR; break;
case PDO_FETCH_ORI_FIRST: ociori = OCI_FETCH_FIRST; break;
case PDO_FETCH_ORI_LAST: ociori = OCI_FETCH_LAST; break;
case PDO_FETCH_ORI_ABS: ociori = OCI_FETCH_ABSOLUTE; break;
case PDO_FETCH_ORI_REL: ociori = OCI_FETCH_RELATIVE; break;
}
S->last_err = OCIStmtFetch2(S->stmt, S->err, 1, ociori, offset, OCI_DEFAULT);
#else
S->last_err = OCIStmtFetch(S->stmt, S->err, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
#endif
if (S->last_err == OCI_NO_DATA) {
/* no (more) data */
return 0;
}
if (S->last_err == OCI_NEED_DATA) {
oci_stmt_error("OCI_NEED_DATA");
return 0;
}
if (S->last_err == OCI_SUCCESS_WITH_INFO || S->last_err == OCI_SUCCESS) {
return 1;
}
oci_stmt_error("OCIStmtFetch");
return 0;
} /* }}} */
bool OWStatement::Fetch( int nRows )
{
sword nStatus = 0;
nStatus = OCIStmtFetch2 (
(OCIStmt*) hStmt,
(OCIError*) poConnection->hError,
(ub4) nRows,
(ub2) OCI_FETCH_NEXT,
(sb4) 0,
(ub4) OCI_DEFAULT );
if( nStatus == OCI_NO_DATA )
{
return false;
}
if( CheckError( nStatus, poConnection->hError ) )
{
return false;
}
return true;
}
static int o_read_database_query (o_database_t *db, /* {{{ */
udb_query_t *q, udb_query_preparation_area_t *prep_area)
{
char **column_names;
char **column_values;
size_t column_num;
OCIStmt *oci_statement;
/* List of `OCIDefine' pointers. These defines map columns to the buffer
* space declared above. */
OCIDefine **oci_defines;
int status;
size_t i;
oci_statement = udb_query_get_user_data (q);
/* Prepare the statement */
if (oci_statement == NULL) /* {{{ */
{
const char *statement;
statement = udb_query_get_statement (q);
assert (statement != NULL);
status = OCIHandleAlloc (oci_env, (void *) &oci_statement,
OCI_HTYPE_STMT, /* user_data_size = */ 0, /* user_data = */ NULL);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIHandleAlloc", oci_error);
oci_statement = NULL;
return (-1);
}
status = OCIStmtPrepare (oci_statement, oci_error,
(text *) statement, (ub4) strlen (statement),
/* language = */ OCI_NTV_SYNTAX,
/* mode = */ OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIStmtPrepare", oci_error);
OCIHandleFree (oci_statement, OCI_HTYPE_STMT);
oci_statement = NULL;
return (-1);
}
udb_query_set_user_data (q, oci_statement);
DEBUG ("oracle plugin: o_read_database_query (%s, %s): "
"Successfully allocated statement handle.",
db->name, udb_query_get_name (q));
} /* }}} */
assert (oci_statement != NULL);
/* Execute the statement */
status = OCIStmtExecute (db->oci_service_context, /* {{{ */
oci_statement,
oci_error,
/* iters = */ 0,
/* rowoff = */ 0,
/* snap_in = */ NULL, /* snap_out = */ NULL,
/* mode = */ OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name, udb_query_get_name (q),
"OCIStmtExecute", oci_error);
return (-1);
} /* }}} */
/* Acquire the number of columns returned. */
do /* {{{ */
{
ub4 param_counter = 0;
status = OCIAttrGet (oci_statement, OCI_HTYPE_STMT, /* {{{ */
¶m_counter, /* size pointer = */ NULL,
OCI_ATTR_PARAM_COUNT, oci_error);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIAttrGet", oci_error);
return (-1);
} /* }}} */
column_num = (size_t) param_counter;
} while (0); /* }}} */
/* Allocate the following buffers:
*
* +---------------+-----------------------------------+
* ! Name ! Size !
* +---------------+-----------------------------------+
* ! column_names ! column_num x DATA_MAX_NAME_LEN !
* ! column_values ! column_num x DATA_MAX_NAME_LEN !
* ! oci_defines ! column_num x sizeof (OCIDefine *) !
* +---------------+-----------------------------------+
*
* {{{ */
#define NUMBER_BUFFER_SIZE 64
#define FREE_ALL \
if (column_names != NULL) { \
sfree (column_names[0]); \
sfree (column_names); \
} \
if (column_values != NULL) { \
sfree (column_values[0]); \
sfree (column_values); \
} \
sfree (oci_defines)
#define ALLOC_OR_FAIL(ptr, ptr_size) \
do { \
size_t alloc_size = (size_t) ((ptr_size)); \
(ptr) = calloc (1, alloc_size); \
if ((ptr) == NULL) { \
FREE_ALL; \
ERROR ("oracle plugin: o_read_database_query: calloc failed."); \
return (-1); \
} \
} while (0)
/* Initialize everything to NULL so the above works. */
column_names = NULL;
column_values = NULL;
oci_defines = NULL;
ALLOC_OR_FAIL (column_names, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_names[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
for (i = 1; i < column_num; i++)
column_names[i] = column_names[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (column_values, column_num * sizeof (char *));
ALLOC_OR_FAIL (column_values[0], column_num * DATA_MAX_NAME_LEN
* sizeof (char));
for (i = 1; i < column_num; i++)
column_values[i] = column_values[i - 1] + DATA_MAX_NAME_LEN;
ALLOC_OR_FAIL (oci_defines, column_num * sizeof (OCIDefine *));
/* }}} End of buffer allocations. */
/* ``Define'' the returned data, i. e. bind the columns to the buffers
* allocated above. */
for (i = 0; i < column_num; i++) /* {{{ */
{
char *column_name;
ub4 column_name_length;
OCIParam *oci_param;
oci_param = NULL;
status = OCIParamGet (oci_statement, OCI_HTYPE_STMT, oci_error,
(void *) &oci_param, (ub4) (i + 1));
if (status != OCI_SUCCESS)
{
/* This is probably alright */
DEBUG ("oracle plugin: o_read_database_query: status = %#x (= %i);",
status, status);
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIParamGet", oci_error);
status = OCI_SUCCESS;
break;
}
column_name = NULL;
column_name_length = 0;
status = OCIAttrGet (oci_param, OCI_DTYPE_PARAM,
&column_name, &column_name_length, OCI_ATTR_NAME, oci_error);
if (status != OCI_SUCCESS)
{
OCIDescriptorFree (oci_param, OCI_DTYPE_PARAM);
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIAttrGet (OCI_ATTR_NAME)", oci_error);
continue;
}
OCIDescriptorFree (oci_param, OCI_DTYPE_PARAM);
oci_param = NULL;
/* Copy the name to column_names. Warning: The ``string'' returned by OCI
* may not be null terminated! */
memset (column_names[i], 0, DATA_MAX_NAME_LEN);
if (column_name_length >= DATA_MAX_NAME_LEN)
column_name_length = DATA_MAX_NAME_LEN - 1;
memcpy (column_names[i], column_name, column_name_length);
column_names[i][column_name_length] = 0;
DEBUG ("oracle plugin: o_read_database_query: column_names[%zu] = %s; "
"column_name_length = %"PRIu32";",
i, column_names[i], (uint32_t) column_name_length);
status = OCIDefineByPos (oci_statement,
&oci_defines[i], oci_error, (ub4) (i + 1),
column_values[i], DATA_MAX_NAME_LEN, SQLT_STR,
NULL, NULL, NULL, OCI_DEFAULT);
if (status != OCI_SUCCESS)
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIDefineByPos", oci_error);
continue;
}
} /* for (j = 1; j <= param_counter; j++) */
/* }}} End of the ``define'' stuff. */
status = udb_query_prepare_result (q, prep_area,
(db->host != NULL) ? db->host : hostname_g,
/* plugin = */ "oracle", db->name, column_names, column_num,
/* interval = */ 0);
if (status != 0)
{
ERROR ("oracle plugin: o_read_database_query (%s, %s): "
"udb_query_prepare_result failed.",
db->name, udb_query_get_name (q));
FREE_ALL;
return (-1);
}
/* Fetch and handle all the rows that matched the query. */
while (42) /* {{{ */
{
status = OCIStmtFetch2 (oci_statement, oci_error,
/* nrows = */ 1, /* orientation = */ OCI_FETCH_NEXT,
/* fetch offset = */ 0, /* mode = */ OCI_DEFAULT);
if (status == OCI_NO_DATA)
{
status = OCI_SUCCESS;
break;
}
else if ((status != OCI_SUCCESS) && (status != OCI_SUCCESS_WITH_INFO))
{
o_report_error ("o_read_database_query", db->name,
udb_query_get_name (q), "OCIStmtFetch2", oci_error);
break;
}
status = udb_query_handle_result (q, prep_area, column_values);
if (status != 0)
{
WARNING ("oracle plugin: o_read_database_query (%s, %s): "
"udb_query_handle_result failed.",
db->name, udb_query_get_name (q));
}
} /* }}} while (42) */
/* DEBUG ("oracle plugin: o_read_database_query: This statement succeeded: %s", q->statement); */
FREE_ALL;
return (0);
#undef FREE_ALL
#undef ALLOC_OR_FAIL
} /* }}} int o_read_database_query */
/*
* Get rows and convert it from oracle to db API representation
*/
static int get_rows(ora_con_t* con, db_res_t* _r, OCIStmt* _c, dmap_t* _d)
{
ub4 rcnt;
sword status;
unsigned n = RES_COL_N(_r);
memcpy(_d->len, _d->ilen, sizeof(_d->len[0]) * n);
// timelimited operation
status = begin_timelimit(con, 0);
if (status != OCI_SUCCESS) goto ora_err;
do status = OCIStmtFetch2(_c, con->errhp, 1, OCI_FETCH_NEXT, 0,
OCI_DEFAULT);
while (wait_timelimit(con, status));
if (done_timelimit(con, status)) goto stop_load;
if (status != OCI_SUCCESS) {
if (status != OCI_NO_DATA)
goto ora_err;
RES_ROW_N(_r) = 0;
RES_ROWS(_r) = NULL;
return 0;
}
status = OCIAttrGet(_c, OCI_HTYPE_STMT, &rcnt, NULL,
OCI_ATTR_CURRENT_POSITION, con->errhp);
if (status != OCI_SUCCESS) goto ora_err;
if (!rcnt) {
LM_ERR("lastpos==0\n");
goto stop_load;
}
RES_ROW_N(_r) = rcnt;
if (db_allocate_rows( _r, rcnt)!=0) {
LM_ERR("no private memory left\n");
return -1;
}
while ( 1 ) {
if (convert_row(_r, &RES_ROWS(_r)[--rcnt], _d) < 0) {
LM_ERR("error convert row\n");
goto stop_load;
}
if (!rcnt)
return 0;
memcpy(_d->len, _d->ilen, sizeof(_d->len[0]) * n);
// timelimited operation
status = begin_timelimit(con, 0);
if (status != OCI_SUCCESS) goto ora_err;
do status = OCIStmtFetch2(_c, con->errhp, 1, OCI_FETCH_PRIOR, 0,
OCI_DEFAULT);
while (wait_timelimit(con, status));
if (done_timelimit(con, status)) goto stop_load;
if (status != OCI_SUCCESS) break;
}
ora_err:
LM_ERR("driver: %s\n", db_oracle_error(con, status));
stop_load:
db_free_rows(_r);
RES_ROW_N(_r) = 0; /* TODO: skipped in db_res.c :) */
return -3;
}
DB_ROW zbx_db_fetch(DB_RESULT result)
{
#if defined(HAVE_IBM_DB2)
int i;
#elif defined(HAVE_ORACLE)
sword rc;
static char errbuf[512];
sb4 errcode;
#endif
if (NULL == result)
return NULL;
#if defined(HAVE_IBM_DB2)
if (SUCCEED != zbx_ibm_db2_success(SQLFetch(result->hstmt))) /* e.g., SQL_NO_DATA_FOUND */
return NULL;
for (i = 0; i < result->ncolumn; i++)
{
result->values[i] = (SQL_NULL_DATA == result->values_len[i] ? NULL : result->values_cli[i]);
}
return result->values;
#elif defined(HAVE_MYSQL)
return mysql_fetch_row(result);
#elif defined(HAVE_ORACLE)
if (OCI_NO_DATA == (rc = OCIStmtFetch2(result->stmthp, oracle.errhp, 1, OCI_FETCH_NEXT, 0, OCI_DEFAULT)))
return NULL;
if (OCI_SUCCESS == rc)
return result->values;
if (OCI_SUCCESS != (rc = OCIErrorGet((dvoid *)oracle.errhp, (ub4)1, (text *)NULL,
&errcode, (text *)errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR)))
{
zabbix_errlog(ERR_Z3006, rc, zbx_oci_error(rc));
return NULL;
}
switch (errcode)
{
case 3113: /* ORA-03113: end-of-file on communication channel */
case 3114: /* ORA-03114: not connected to ORACLE */
zabbix_errlog(ERR_Z3006, errcode, errbuf);
return NULL;
}
return result->values;
#elif defined(HAVE_POSTGRESQL)
/* free old data */
if (NULL != result->values)
zbx_free(result->values);
/* EOF */
if (result->cursor == result->row_num)
return NULL;
/* init result */
result->fld_num = PQnfields(result->pg_result);
if (result->fld_num > 0)
{
int i;
result->values = zbx_malloc(result->values, sizeof(char *) * result->fld_num);
for (i = 0; i < result->fld_num; i++)
{
if (PQgetisnull(result->pg_result, result->cursor, i))
{
result->values[i] = NULL;
}
else
{
result->values[i] = PQgetvalue(result->pg_result, result->cursor, i);
if (PQftype(result->pg_result, i) == ZBX_PG_BYTEAOID) /* binary data type BYTEAOID */
zbx_pg_unescape_bytea((u_char *)result->values[i]);
}
}
}
result->cursor++;
return result->values;
#elif defined(HAVE_SQLITE3)
/* EOF */
if (result->curow >= result->nrow)
return NULL;
if (NULL == result->data)
return NULL;
result->curow++; /* NOTE: first row == header row */
return &(result->data[result->curow * result->ncolumn]);
#endif
}
static int yada_oracle_fetch(yada_t *_yada, yada_rc_t *rrc, yada_rc_t *brc)
{
char errbuf[1024];
sb4 errcode;
int i;
yada_bindset_t *bs;
bindset_ele_t *bse;
extinfo *info;
bs = brc->data;
info = (extinfo*)rrc->data;
/* check if database connection disappeared */
if(info->invalid)
{
_yada_set_err(_yada, -1, "database unavailable");
return(0);
}
/* check database connection */
if(!_yada->_mod->env && !_yada->connect(_yada, NULL, NULL))
return(0);
/* create oracle bindings on the fly */
if(info->bind)
{
if(yada_oracle_bind(_yada, info->stmt, bs))
return(0);
info->bind = 0;
}
/* fetch rows into buffers */
#ifdef OBSOLETE_OCI
switch(OCIStmtFetch(info->stmt, _yada->_mod->err, 1,
OCI_FETCH_NEXT, OCI_DEFAULT))
{
#else
switch(OCIStmtFetch2(info->stmt, _yada->_mod->err, 1,
OCI_FETCH_NEXT, 0, OCI_DEFAULT))
{
#endif
/************************************************/
case OCI_SUCCESS:
/************************************************/
/* fetch succeeded */
break;
/************************************************/
case OCI_SUCCESS_WITH_INFO:
/************************************************/
/* fetch succeeded -- store warning info */
OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
OCI_HTYPE_ERROR);
_yada_set_err(_yada, errcode, errbuf);
break;
/************************************************/
case OCI_NO_DATA:
/************************************************/
/* no more data to fetch */
_yada->error = 0;
return(0);
/************************************************/
default:
/************************************************/
OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
OCI_HTYPE_ERROR);
_yada_set_err(_yada, errcode, errbuf);
_yada->disconnect(_yada);
return(0);
/************************************************/
} /* switch(status) */
/* tweek bound data */
for(i=0, bse=bs->ele; i<bs->eles; i++, bse++)
{
if(bse->t <= 0)
{
switch(*(sb2*)&bse->ind)
{
/************************************************/
case 0:
/************************************************/
/* value contained a result */
*(void**)bse->ptr = bse->var.buf;
break;
/************************************************/
case -1:
/************************************************/
/* value was NULL */
*(void**)bse->ptr = NULL;
break;
/************************************************/
default:
/************************************************/
/* value didn't fit in buffer */
_yada_set_err(_yada, ENAMETOOLONG, "value too large for buffer");
return(0);
/************************************************/
} /* switch(indicator) */
} /* if(bind_ptr) */
switch(bse->t)
{
/************************************************/
case -'d':
/************************************************/
/* update pointer if value was successful */
*(void**)bse->ptr = (*(sb2*)&bse->ind ? NULL : &bse->var.i);
break;
/************************************************/
case 'l':
/************************************************/
/* update user-supplied value */
*(long long*)bse->ptr = (*(sb2*)&bse->ind ? 0 : atoll(bse->tmp));
break;
/************************************************/
case -'l':
/************************************************/
/* update pointer if value was successful */
if(*(sb2*)&bse->ind)
*(void**)bse->ptr = NULL;
else
{
bse->var.l = atoll(bse->tmp);
*(void**)bse->ptr = &bse->var.l;
}
break;
/************************************************/
case 'b':
case -'b':
/************************************************/
/* convert size to int */
bse++;
i++;
*(int*)bse->ptr = (int)*(sb2*)&bse->var.i;
break;
/************************************************/
} /* switch(bind_type) */
} /* foreach(binding) */
return(1);
}
/******************************************************************************/
/** get the last insert id
* @returns last insert id, or 0 on failure
*/
static uint64_t yada_oracle_insert_id(yada_t *_yada, char *table, char *col)
{
/* this needs to be user set */
return(0);
}
/******************************************************************************/
/** create and init yada struct
* @returns non zero on success, 0 on error
*/
int yada_mod_init(yada_t *_yada)
{
if(!(_yada->_mod = calloc(1, sizeof(yada_modpriv_t))))
return(0);
_yada_set_err(_yada, 0, "no error reported");
/* yada module base functions */
_yada->type_id = YADA_ORACLE;
_yada->connect = yada_oracle_connect;
_yada->disconnect = yada_oracle_disconnect;
/* native prepare funtions */
_yada->prepare = _yada_prepare;
_yada->preparef = _yada_preparef;
/* yada compat prepare funtions */
_yada->yprepare = _yada_prepare;
_yada->ypreparef = _yada_preparef;
_yada->xprepare = _yada_xprepare;
_yada->execute = _yada_execute;
_yada->xexecute = _yada_xexecute;
_yada->query = _yada_query;
_yada->xquery = _yada_xquery;
/* yada util functions */
_yada->escstr = yada_oracle_escstr;
_yada->dumpexec = _yada_dumpexec;
/* yada compat bind functions */
_yada->bind = _yada_bind;
_yada->fetch = yada_oracle_fetch;
/* var args functions */
_yada->vquery = _yada_vquery;
_yada->vbind = _yada_vbind;
_yada->vexecute = _yada_vexecute;
/* transaction functions */
_yada->trx = yada_oracle_trx;
_yada->commit = yada_oracle_commit;
_yada->rollback = yada_oracle_rollback;
_yada->insert_id = yada_oracle_insert_id;
/* private interfaces */
_yada->_priv->exec = yada_oracle__exec;
_yada->_priv->query = yada_oracle__query;
_yada->_priv->destroy = yada_oracle__destroy;
_yada->_priv->free_rc[YADA_STATEMENT] = _yada_free_stmt;
_yada->_priv->free_rc[YADA_RESULT] = yada_oracle_free_result;
_yada->_priv->free_rc[YADA_BINDSET] = yada_oracle_free_bindset;
return(1);
}
