Beispiel #1
0
bool OWConnection::GetNextField( OCIParam* phTable,
                                 int nIndex,
                                 char* pszName,
                                 int* pnType,
                                 int* pnSize,
                                 int* pnPrecision,
                                 signed short* pnScale )
{
    OCIParam* hParmDesc = NULL;

    sword nStatus = 0;

    nStatus = OCIParamGet(
        phTable,
        (ub4) OCI_DTYPE_PARAM,
        hError,
        (dvoid**) &hParmDesc,   //Warning
        (ub4) nIndex + 1 );

    if( nStatus != OCI_SUCCESS )
    {
        return false;
    }

    char* pszFieldName = NULL;
    ub4 nNameLength = 0;

    CheckError( OCIAttrGet(
        hParmDesc,
        (ub4) OCI_DTYPE_PARAM,
        (dvoid*) &pszFieldName,
        (ub4*) &nNameLength,
        (ub4) OCI_ATTR_NAME,
        hError ), hError );

    ub2 nOCIType = 0;

    CheckError( OCIAttrGet(
        hParmDesc,
        (ub4) OCI_DTYPE_PARAM,
        (dvoid*) &nOCIType,
        (ub4*) NULL,
        (ub4) OCI_ATTR_DATA_TYPE,
        hError ), hError );

    ub2 nOCILen = 0;

    CheckError( OCIAttrGet(
        hParmDesc,
        (ub4) OCI_DTYPE_PARAM,
        (dvoid*) &nOCILen,
        (ub4*) NULL,
        (ub4) OCI_ATTR_DATA_SIZE,
        hError ), hError );

    unsigned short nOCIPrecision = 0;
    sb1 nOCIScale = 0;

    if( nOCIType == SQLT_NUM )
    {
        CheckError( OCIAttrGet(
            hParmDesc,
            (ub4) OCI_DTYPE_PARAM,
            (dvoid*) &nOCIPrecision,
            (ub4*) 0,
            (ub4) OCI_ATTR_PRECISION,
            hError ), hError );

        CheckError( OCIAttrGet(
            hParmDesc,
            (ub4) OCI_DTYPE_PARAM,
            (dvoid*) &nOCIScale,
            (ub4*) 0,
            (ub4) OCI_ATTR_SCALE,
            hError ), hError );

        if( nOCIPrecision > 255 ) // Lesson learned from ogrocisession.cpp
        {
            nOCIPrecision = nOCIPrecision / 256;
        }
    }

    nNameLength = MIN( nNameLength, OWNAME );

    strncpy( pszName, pszFieldName, nNameLength);
    pszName[nNameLength] = '\0';

    *pnType      = (int) nOCIType;
    *pnSize      = (int) nOCILen;
    *pnPrecision = (int) nOCIPrecision;
    *pnScale     = (signed short) nOCIScale;

    return true;

}
Beispiel #2
0
// Remove the update queue tables associted with every data source.
void remove_update_queue_tables_and_native_triggers(void)
{
	char statement[DB_MAX_SIZE];
	OCIParam  *param_desc;
	OCIDefine *defn_handle;
	int        length;
	int        result;
	short      len, status;
	char       column_val[NUM_COLS][DB_MAX_SIZE]; // column_val[0] - updqueuename
	                                              // column_val[1] - instrigname
	                                              // column_val[2] - updtrigname
	                                              // column_val[3] - deltrigname

	// allocate a statement handle
	OCIHandleAlloc(db_connection1->envhp, (dvoid **)&(db_connection1->stmthp), OCI_HTYPE_STMT, 0, NULL);
	
	// prepare the statement
	statement[0] = '\0';
	sprintf(statement, "select updqueuename, instrigname, updtrigname, deltrigname from vl_datasrc");
	result = OCIStmtPrepare(db_connection1->stmthp,
		  	                db_connection1->errhp,
				            (unsigned char *)statement, 
				            strlen(statement),
				            OCI_NTV_SYNTAX,
				            OCI_DEFAULT);
	checkerr(db_connection1->errhp, result);
	
	// The way we execute the statement depends on whether or not there
	// are any dynamic variables to bind.
    result = OCIStmtExecute(db_connection1->svchp,
		                    db_connection1->stmthp,
				            db_connection1->errhp,
				            0,
				            0,
				            NULL,
				            NULL,
				            OCI_DEFAULT);
	checkerr(db_connection1->errhp, result);
	if (result == OCI_ERROR || result == OCI_NO_DATA)
	{
		return;
	}
	
	do
	{		
		int i;
		for (i = 1; i <= NUM_COLS; i++)
		{
		
			// Get the description of the current column
			result = OCIParamGet(db_connection1->stmthp,
			                     OCI_HTYPE_STMT,
				                 db_connection1->errhp,
				                 &param_desc,
				                 i);
			checkerr(db_connection1->errhp, result);
			
			// set the column's maximum length
			result = OCIAttrGet(param_desc,
				                OCI_DTYPE_PARAM,
							    &len,
							    NULL,
							    OCI_ATTR_DATA_SIZE,
							    db_connection1->errhp);
			checkerr(db_connection1->errhp, result);
			
			// add one space for the NULL terminator
			length = (short) (len + 1);
			
			// Get the value of the current column.
			result = OCIDefineByPos(db_connection1->stmthp,
				                    &defn_handle,
				                    db_connection1->errhp,
				                    i,
				                    column_val[i-1],
				                    length,
				                    SQLT_STR,
				                    &status,
				                    NULL,
				                    NULL,
				                    OCI_DEFAULT);
			checkerr(db_connection1->errhp, result);
		}
		// Fetch the next row
		result = OCIStmtFetch(db_connection1->stmthp,
			                  db_connection1->errhp,
			                  1, // number of rows to fetch
			                  OCI_FETCH_NEXT,
			                  OCI_DEFAULT );
		
		// No more rows to fetch
		if (result == OCI_NO_DATA) 
		{
			break;
		}
		else
		{
			char drop_stmt[DB_MAX_SIZE];

            checkerr(db_connection1->errhp, result);

			drop_stmt[0] = '\0';
			sprintf(drop_stmt, "drop trigger \"%s\"", column_val[1]);
			exec_sql_stmt(drop_stmt);
			puts(column_val[1]);

			drop_stmt[0] = '\0';
			sprintf(drop_stmt, "drop trigger \"%s\"", column_val[2]);
			exec_sql_stmt(drop_stmt);
			puts(column_val[2]);

			drop_stmt[0] = '\0';
			sprintf(drop_stmt, "drop trigger \"%s\"", column_val[3]);
			exec_sql_stmt(drop_stmt);
			puts(column_val[3]);
		
			drop_stmt[0] = '\0';
			sprintf(drop_stmt, "drop table \"%s\"", column_val[0]);
			exec_sql_stmt(drop_stmt);
			puts(column_val[0]);
		}
	} while (result != OCI_NO_DATA);

		// close the statement
	result = OCIStmtFetch(db_connection1->stmthp,
	                       db_connection1->errhp,
						   0,
						   OCI_FETCH_NEXT,
						   OCI_DEFAULT);
	checkerr(db_connection1->errhp, result);		

	// Close the statement handle
	OCIHandleFree(db_connection1->stmthp, OCI_HTYPE_STMT);
}	
Beispiel #3
0
static int yada_oracle_bind(yada_t *_yada, OCIStmt *stmt, yada_bindset_t *bs)
{
  int i, ctr;
  ub2 type;
  sb4 errcode;
  char errbuf[1024];
  OCIParam *param;
  OCIDefine *def;
  bindset_ele_t *bse;


  /* determine number of actual bindings */
  for(i=ctr=0, bse=bs->ele; i<bs->eles; i++, bse++)
    {
    ctr++;
    if((bse->t == 'b') || (bse->t == -'b'))
      {
      bse++;
      i++;
      }
    }

  /* check number of parameters */
  if(OCIAttrGet(stmt, OCI_HTYPE_STMT, &i, NULL,
   OCI_ATTR_PARAM_COUNT, _yada->_mod->err) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    return(-1);
    }
  if(i != ctr)
    {
    _yada_set_err(_yada, EBADE, "parameter count mismatch");
    return(-1);
    }


  /* prepare each select-list item */
  for(i=1, bse=bs->ele; i<=ctr; i++, bse++)
    {
    def = NULL;

    if((OCIParamGet(stmt, OCI_HTYPE_STMT,
     _yada->_mod->err, (dvoid*)&param, i)) != OCI_SUCCESS)
      {
      OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
       OCI_HTYPE_ERROR);
      _yada_set_err(_yada, errcode, errbuf);
      return(-1);
      }
    if((OCIAttrGet(param, OCI_DTYPE_PARAM, &type, 0,
     OCI_ATTR_DATA_TYPE, _yada->_mod->err)) != OCI_SUCCESS)
      {
      OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
       OCI_HTYPE_ERROR);
      _yada_set_err(_yada, errcode, errbuf);
      return(-1);
      }


    switch(bse->t)
      {
    /************************************************/
    case 'b':
    /************************************************/
      /* user allocated binary string */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->ptr,
       MAXDATA, SQLT_STR, &bse->ind, (ub2*)&bse[1].var.i, 0, OCI_DEFAULT);
      bse++;
      break;
    /************************************************/
    case 'd':
    /************************************************/
      /* user allocated int */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->ptr,
       sizeof(int), SQLT_INT, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case 'f':
    /************************************************/
      /* user allocated int */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->ptr,
       sizeof(double), SQLT_FLT, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case 'l':
    /************************************************/
      /* user allocated int 64
       * alloc for string and then convert after fetch
       */
      if(!(bse->tmp = (unsigned char*)malloc(STRLEN_INT64)))
        {
        _yada_set_yadaerr(_yada, YADA_ENOMEM);
        return(-1);
        }

      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->tmp,
       STRLEN_INT64, SQLT_STR, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case 's':
    case 'e':
    case 'v':
    /************************************************/
      /* user allocated string */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->ptr,
       MAXDATA, SQLT_STR, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case -'b':
    /************************************************/
      /* allocate space for data */
      if(!(bse->var.buf = (unsigned char*)malloc(MAXDATA)))
        {
        _yada_set_yadaerr(_yada, YADA_ENOMEM);
        return(-1);
        }

      /* locally allocated binary string */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->var.buf,
       MAXDATA, SQLT_STR, &bse->ind, (ub2*)&bse[1].var.i, 0, OCI_DEFAULT);
      bse++;
      break;
    /************************************************/
    case -'d':
    /************************************************/
      /* locally provided int */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, &bse->var.i,
       sizeof(int), SQLT_INT, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case -'f':
    /************************************************/
      /* locally provided int */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, &bse->var.f,
       sizeof(double), SQLT_FLT, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case -'l':
    /************************************************/
      /* locally provided int 64
       * alloc for string and then copy after fetch
       */
      if(!(bse->tmp = (unsigned char*)malloc(STRLEN_INT64)))
        {
        _yada_set_yadaerr(_yada, YADA_ENOMEM);
        return(-1);
        }

      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->tmp,
       STRLEN_INT64, SQLT_STR, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
    case -'s':
    case -'e':
    case -'v':
    /************************************************/
      /* allocate space for string */
      if(!(bse->var.buf = (unsigned char*)malloc(MAXDATA)))
        {
        _yada_set_yadaerr(_yada, YADA_ENOMEM);
        return(-1);
        }

      /* localy allocated string */
      OCIDefineByPos(stmt, &def, _yada->_mod->err, i, bse->var.buf,
       MAXDATA, SQLT_STR, &bse->ind, 0, 0, OCI_DEFAULT);
      break;
    /************************************************/
      } /* switch(bind_type) */
    } /* foreach(binding) */

  return(0);
}
Beispiel #4
0
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, /* {{{ */
        &param_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) = malloc (alloc_size); \
    if ((ptr) == NULL) { \
      FREE_ALL; \
      ERROR ("oracle plugin: o_read_database_query: malloc failed."); \
      return (-1); \
    } \
    memset ((ptr), 0, alloc_size); \
  } 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, 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 */
Beispiel #5
0
/*
 * 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;
}
Beispiel #6
0
void HandleCmd(char *sql) {
	int type, size;
	CheckErr(herr, OCIStmtPrepare(hsql, herr, (text*)sql, strlen(sql), OCI_NTV_SYNTAX, OCI_DEFAULT));
	CheckErr(herr, OCIAttrGet(hsql, OCI_HTYPE_STMT, &type, (ub4*)&size, OCI_ATTR_STMT_TYPE, herr));
	HandleSqlByType(sql, type);
}
Beispiel #7
0
/*
 * 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_LAST, 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("erroc 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;
}
                (
                    pOCILib, res, con, 
                    
                    OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->ccode, 
                               NULL, OCI_ATTR_COLLECTION_TYPECODE, con->err),

		    xsink
                )
            }
            else
            {
                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &parmh2, 
                               NULL, attr_type, con->err),

		    xsink
                )

                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->nb_cols,
                               NULL, num_type, con->err),

		    xsink
                )
            }
         
OCI_TypeInfo * OCI_API OCI_TypeInfoGet2(OCI_Library *pOCILib, OCI_Connection *con, const mtext *name, 
					unsigned int type, ExceptionSink* xsink)
{
    OCI_TypeInfo *typinf = NULL;
    OCI_Item     *item   = NULL;
    OCIDescribe *dschp   = NULL;
    OCIParam *parmh1     = NULL;
    OCIParam *parmh2     = NULL;
    mtext *str           = NULL;
    //int etype            = OCI_DESC_COLUMN;
    int ptype            = 0;
    ub1 item_type        = 0;
    ub4 attr_type        = 0;
    ub4 num_type         = 0;
    boolean res          = TRUE;
    boolean found        = FALSE;
    ub2 i;
    
    mtext obj_schema[OCI_SIZE_OBJ_NAME+1];
    mtext obj_name[OCI_SIZE_OBJ_NAME+1];

    OCI_CHECK_INITIALIZED2(pOCILib, NULL);

    OCI_CHECK_PTRQ(pOCILib, OCI_IPC_CONNECTION, con, NULL, xsink);
    OCI_CHECK_PTRQ(pOCILib, OCI_IPC_STRING, name, NULL, xsink);

    if (type == OCI_TIF_TABLE)
        item_type = OCI_PTYPE_TABLE;
    else if (type == OCI_TIF_VIEW)
        item_type = OCI_PTYPE_VIEW;
    else if (type == OCI_TIF_TYPE)
        item_type = OCI_PTYPE_TYPE;
    else
        return NULL;

    obj_schema[0] = 0;
    obj_name[0] = 0;

    /* is the schema provided in the object name ? */

    for (str = (mtext *) name; *str != 0; str++)
    {
        if (*str == MT('.'))
        {
            mtsncat(obj_schema, name, str-name);
            mtsncat(obj_name, ++str, (size_t) OCI_SIZE_OBJ_NAME);
            break;
        }
    }

    /* if the schema is not provided, we just copy the object name */

    if (obj_name[0] == 0)
    {
        mtsncat(obj_name, name, (size_t) OCI_SIZE_OBJ_NAME);
    }

    /* type name must be uppercase */

    for (str = obj_name; *str != 0; str++)
        *str = (mtext) mttoupper(*str);

    /* schema name must be uppercase */

    for (str = obj_schema; *str != 0; str++)
        *str = (mtext) mttoupper(*str);

    /* first try to find it in list */

    item = con->tinfs->head;

    /* walk along the list to find the type */

    while (item != NULL)
    {
        typinf = (OCI_TypeInfo *) item->data;
     
        if ((typinf != NULL) && (typinf->type == type))
        {
            if ((mtscasecmp(typinf->name,   obj_name  ) == 0) &&
                (mtscasecmp(typinf->schema, obj_schema) == 0))
            {
                found = TRUE;
                break;
            }
        }

        item = item->next;
    } 

    /* Not found, so create type object */

    if (found == FALSE)
    {
        item = OCI_ListAppend(pOCILib, con->tinfs, sizeof(OCI_TypeInfo));

        res = (item != NULL);

        if (res == TRUE)
        {
            typinf = (OCI_TypeInfo *) item->data;

            typinf->type        = type;
            typinf->con         = con;
            typinf->name        = mtsdup(pOCILib, obj_name);
            typinf->schema      = mtsdup(pOCILib, obj_schema);
            typinf->struct_size = 0;

            res = (OCI_SUCCESS == OCI_HandleAlloc2(pOCILib, pOCILib->env,
                                                  (dvoid **) (void *) &dschp, 
                                                  OCI_HTYPE_DESCRIBE, (size_t) 0, 
                                                  (dvoid **) NULL));
        }

        if (res == TRUE)
        {
            if (type == OCI_TIF_TYPE)
            {            
                void *ostr1 = NULL;
                void *ostr2 = NULL;
                int osize1  = -1;
                int osize2  = -1;
               
                attr_type = OCI_ATTR_LIST_TYPE_ATTRS;
                num_type  = OCI_ATTR_NUM_TYPE_ATTRS;
                ptype     = OCI_DESC_TYPE;

                ostr1 = OCI_GetInputMetaString(pOCILib, typinf->schema, &osize1);
                ostr2 = OCI_GetInputMetaString(pOCILib, typinf->name,   &osize2);

                OCI_CALL2Q
                (
		   pOCILib, res, con, 
                   
		   OCITypeByName(pOCILib->env, con->err, con->cxt,
                                 (text *) ostr1, (ub4) osize1, 
                                 (text *) ostr2, (ub4) osize2, 
                                 (text *) NULL, (ub4) 0, 
                                 OCI_DURATION_SESSION, OCI_TYPEGET_ALL,
                                 &typinf->tdo),

		   xsink
                )

                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIDescribeAny(con->cxt, con->err, (void *) typinf->tdo,
                                   0, OCI_OTYPE_PTR, OCI_DEFAULT, 
                                   OCI_PTYPE_TYPE, dschp),

		    xsink
                )
                
                OCI_ReleaseMetaString(ostr1);
                OCI_ReleaseMetaString(ostr2);
            }
            else
            {
                mtext buffer[(OCI_SIZE_OBJ_NAME*2) + 2];
                
                size_t size = sizeof(buffer)/sizeof(mtext);
                void *ostr1 = NULL;
                int osize1  = -1;

                attr_type = OCI_ATTR_LIST_COLUMNS;
                num_type  = OCI_ATTR_NUM_COLS;
                ptype     = OCI_DESC_TABLE;
                str       = buffer;

                str[0] = 0;                

                if ((typinf->schema != NULL) && (typinf->schema[0] != 0))
                {
                    str = mtsncat(buffer, typinf->schema, size);
                    size -= mtslen(typinf->schema);
                    str = mtsncat(str, MT("."), size);
                    size -= (size_t) 1;
                }

                mtsncat(str, typinf->name, size);

                ostr1 = OCI_GetInputMetaString(pOCILib, str, &osize1);

                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIDescribeAny(con->cxt, con->err, (dvoid *) ostr1, 
                                   (ub4) osize1, OCI_OTYPE_NAME, 
                                   OCI_DEFAULT, item_type, dschp),

		    xsink
                )

                OCI_ReleaseMetaString(ostr1);
            }
                  
            OCI_CALL2Q
            (
                pOCILib, res, con, 
                
                OCIAttrGet(dschp, OCI_HTYPE_DESCRIBE, &parmh1, 
                           NULL, OCI_ATTR_PARAM, con->err),

		xsink
            )

            /* do we need get more attributes for collections ? */

            if (type == OCI_TIF_TYPE)
            {
                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->tcode, 
                               NULL, OCI_ATTR_TYPECODE, con->err),

		    xsink
                )

            }

            if (typinf->tcode == SQLT_NCO)
            {      
                typinf->nb_cols = 1;
                
                ptype  = OCI_DESC_COLLECTION;
                //etype  = OCI_DESC_TYPE;
                parmh2 = parmh1;

                OCI_CALL2Q
                (
                    pOCILib, res, con, 
                    
                    OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->ccode, 
                               NULL, OCI_ATTR_COLLECTION_TYPECODE, con->err),

		    xsink
                )
            }
            else
            {
Beispiel #10
0
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;
}
Beispiel #11
0
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;
}
Beispiel #12
0
bool COracleRecordset::Init(COracleConnection *parent, OCIStmt *hStmt, bool select)
{
	sb4 status;
	int is_string_data=0;
	m_bEof = false;
	m_parent = parent;
	m_hStmt = hStmt;

	if (select)
	{
	CServerIo::trace(3,"COracleRecordset::Init -  OCIStmtExecute(Describe_Only,select=%d)",select?0:1);
	status=OCIStmtExecute(parent->m_hSvcCtx, hStmt, parent->m_hErr, select?0:1, 0, NULL, NULL, OCI_DESCRIBE_ONLY);
	} else {
	CServerIo::trace(3,"COracleRecordset::Init -  OCIStmtExecute(%s,select=%d)",parent->m_bAutoCommit?"OCI_COMMIT_ON_SUCCESS":"OCI_DEFAULT",select?0:1);
	status=OCIStmtExecute(parent->m_hSvcCtx, hStmt, parent->m_hErr, select?0:1, 0, NULL, NULL, parent->m_bAutoCommit?OCI_COMMIT_ON_SUCCESS:OCI_DEFAULT);
	}
	CServerIo::trace(3,"COracleRecordset::Init -  CheckError(%d)",(int)status);
	if(!parent->CheckError(parent->m_hErr,status))
		return false;

	CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_PARAM_COUNT)");
	status=OCIAttrGet(hStmt, OCI_HTYPE_STMT, &m_num_fields, 0, OCI_ATTR_PARAM_COUNT, parent->m_hErr);
	CServerIo::trace(3,"COracleRecordset::Init -  CheckError(%d) m_num_fields=%d",(int)status,(int)m_num_fields);
	if(!parent->CheckError(parent->m_hErr,status))
		return false;

	CServerIo::trace(3,"COracleRecordset::Init -  resize");
	m_sqlfields.resize(m_num_fields);
	CServerIo::trace(3,"COracleRecordset::Init -  for loop");
	for(size_t n=0; n<m_num_fields; n++)
	{
		OCIParam *hParam;
		wchar_t szCol[128];
		ub4 ubCol = sizeof(szCol);
		unsigned char *szaColPtr;
		ub4 ubaCol = 0;

		CServerIo::trace(3,"COracleRecordset::Init -  for loop %d",(int)n);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIParamGet(OCI_HTYPE_STMT) n==%d",n+1);
		OCIParamGet(hStmt, OCI_HTYPE_STMT, parent->m_hErr, (void**)&hParam, n+1);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_DATA_TYPE)");
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].type, NULL, OCI_ATTR_DATA_TYPE, parent->m_hErr);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_TYPECODE)");
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].typecode, NULL, OCI_ATTR_TYPECODE, parent->m_hErr);
		switch (m_sqlfields[n].type) {
		case OCI_TYPECODE_REF:
			CServerIo::trace(3,"  - TYPECODE REF");
			break;
		case OCI_TYPECODE_DATE:
			CServerIo::trace(3,"  - TYPECODE DATE");
			break;
		case OCI_TYPECODE_REAL:
			CServerIo::trace(3,"  - TYPECODE REAL");
			break;
		case OCI_TYPECODE_DOUBLE:
			CServerIo::trace(3,"  - TYPECODE DOUBLE");
			break;
		case OCI_TYPECODE_FLOAT:
			CServerIo::trace(3,"  - TYPECODE FLOAT");
			break;
		case OCI_TYPECODE_NUMBER:
			CServerIo::trace(3,"  - TYPECODE NUMBER");
			break;
		case OCI_TYPECODE_DECIMAL:
			CServerIo::trace(3,"  - TYPECODE DECIMAL");
			break;
		case OCI_TYPECODE_OCTET:
			CServerIo::trace(3,"  - TYPECODE OCTET");
			break;
		case OCI_TYPECODE_INTEGER:
			CServerIo::trace(3,"  - TYPECODE INTEGER");
			break;
		case OCI_TYPECODE_SMALLINT:
			CServerIo::trace(3,"  - TYPECODE SMALLINT");
			break;
		case OCI_TYPECODE_RAW:
			CServerIo::trace(3,"  - TYPECODE RAW");
			break;
		case OCI_TYPECODE_VARCHAR2:
			CServerIo::trace(3,"  - TYPECODE VARCHAR2");
			break;
		case OCI_TYPECODE_VARCHAR:
			CServerIo::trace(3,"  - TYPECODE VARCHAR");
			break;
		case OCI_TYPECODE_CHAR:
			CServerIo::trace(3,"  - TYPECODE CHAR");
			break;
		case OCI_TYPECODE_VARRAY:
			CServerIo::trace(3,"  - TYPECODE VARRAY");
			break;
		case OCI_TYPECODE_TABLE:
			CServerIo::trace(3,"  - TYPECODE TABLE");
			break;
		case OCI_TYPECODE_CLOB:
			CServerIo::trace(3,"  - TYPECODE CLOB");
			break;
		case OCI_TYPECODE_BLOB:
			CServerIo::trace(3,"  - TYPECODE BLOB");
			break;
		case OCI_TYPECODE_BFILE:
			CServerIo::trace(3,"  - TYPECODE BFILE");
			break;
		case OCI_TYPECODE_OBJECT:
			CServerIo::trace(3,"  - TYPECODE OBJECT");
			break;
		case OCI_TYPECODE_NAMEDCOLLECTION:
			CServerIo::trace(3,"  - TYPECODE NAMED COLL.");
			break;
		default:
			CServerIo::trace(3,"  - TYPECODE unknown");
		}
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_NAME)");
		szaColPtr=NULL;
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, (void**)&szaColPtr, &ubaCol, OCI_ATTR_NAME, parent->m_hErr);
		if (szaColPtr!=NULL)
		CServerIo::trace(3,"  - ATTR_NAME %s (%d).",szaColPtr,(int)ubaCol);
		else
		CServerIo::trace(3,"  - ATTR_NAME NULL (%d).",(int)ubaCol);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_PRECISION)");
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].precision, NULL, OCI_ATTR_PRECISION, parent->m_hErr);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_SCALE)");
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].scale, NULL, OCI_ATTR_SCALE, parent->m_hErr);
		CServerIo::trace(3,"COracleRecordset::Init -  OCIAttrGet(OCI_ATTR_DATA_SIZE)");
		OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].size, NULL, OCI_ATTR_DATA_SIZE, parent->m_hErr);
		CServerIo::trace(3,"  - ATTR_DATA_SIZE %d.",(int)m_sqlfields[n].size);

		m_sqlfields[n].field = n;
		m_sqlfields[n].hStmt = m_hStmt;
		m_sqlfields[n].name = cvs::wide((char *)szaColPtr);

		switch(m_sqlfields[n].type)
		{
		case OCI_TYPECODE_REAL:
		case OCI_TYPECODE_FLOAT:
		case OCI_TYPECODE_DOUBLE:
			CServerIo::trace(3," ::Init -  OCI_TYPECODE_REAL");
			m_sqlfields[n].fldtype=SQLT_FLT;
			m_sqlfields[n].fldlen=sizeof(double);
			break;
		case OCI_TYPECODE_OCTET:
		case OCI_TYPECODE_INTEGER:
		case OCI_TYPECODE_SMALLINT:
			CServerIo::trace(3," ::Init -  OCI_TYPECODE_OCTET");
			m_sqlfields[n].fldtype=SQLT_INT;
			m_sqlfields[n].fldlen=sizeof(int);
			break;
		case OCI_TYPECODE_NUMBER:
			CServerIo::trace(3," ::Init -  OCI_TYPECODE_NUMBER");
			if(m_sqlfields[n].precision)
			{
				m_sqlfields[n].fldtype=SQLT_FLT;
				m_sqlfields[n].fldlen=sizeof(double);
			}
			else
			{
				m_sqlfields[n].fldtype=SQLT_INT;
				m_sqlfields[n].fldlen=sizeof(int);
			}
			break;
		case OCI_TYPECODE_VARCHAR2:
		case OCI_TYPECODE_VARCHAR:
		case OCI_TYPECODE_CHAR:
		case OCI_TYPECODE_CLOB:
		case OCI_TYPECODE_BLOB:
		case OCI_TYPECODE_DATE:
			CServerIo::trace(3," ::Init -  OCI_TYPECODE_VARCHAR2");
			m_sqlfields[n].fldtype=SQLT_STR;
			m_sqlfields[n].fldlen=m_sqlfields[n].size+1;
			is_string_data=1;
			break;
		case OCI_TYPECODE_REF:
		case OCI_TYPECODE_RAW:
		case OCI_TYPECODE_VARRAY:
		case OCI_TYPECODE_TABLE:
		case OCI_TYPECODE_BFILE:
		case OCI_TYPECODE_OBJECT:
		case OCI_TYPECODE_NAMEDCOLLECTION:
		default:
			CServerIo::trace(3," ::Init -  Unsuppoered datatype");
			//CServerIo::error("Field type %d unsupported for field %s\n",m_sqlfields[n].type,(const char *)cvs::narrow(szCol));
			CServerIo::error("Field type %d unsupported for field %s\n",m_sqlfields[n].type,szaColPtr);
			return false;
		}

		CServerIo::trace(3," ::Init -  end of datatype");
		if(m_sqlfields[n].fldlen)
		{
			OCIDefine *hDef = NULL;
			CServerIo::trace(3," ::Init -  m_sqlfields[n].fldlen=%d",(int)m_sqlfields[n].fldlen);

			if ((m_sqlfields[n].fldtype==SQLT_STR) ||
			    (is_string_data))
			{
			// the result of the OCI DefineByPos is a buffer of 
			// characters.  We could leave just that but
			// this (incorrectly?) assumes the OCI client is
			// going to present this data as UTF8.  In truth
			// it is based on the bind OCI_HTYPE_BIND attribute 
			// OCI_ATTR_CHARSET_ID
			CServerIo::trace(3," ::Init -  OCIAttrGet(OCI_ATTR_CHARSET_ID)");
			OCIAttrGet(hParam, OCI_DTYPE_PARAM, &m_sqlfields[n].csid, NULL, OCI_ATTR_CHARSET_ID, parent->m_hErr);
			if (m_sqlfields[n].csid == OCI_UCS2ID)
				CServerIo::trace(3," ::Init -  UCS2 Charset");
			if (m_sqlfields[n].csid == 2000 /* OCI_UTF16ID */)
				CServerIo::trace(3," ::Init -  UTF16 Charset");
			else
				CServerIo::trace(3," ::Init -  Charset %d (not UCS2)",(int)m_sqlfields[n].csid);
			/* The only valid handle types for setting charset are:
			  Bind Handle 
			  Define Handle
			  Direct Path Loading Handle
			  Direct Path Column Parameter
			  */
			/*
			CServerIo::trace(3,"COracleRecordset::Init -  OCIParamGet(OCI_DTYPE_PARM)");
			OCIParamGet(hParam, OCI_DTYPE_PARM, parent->m_hErr, (void **)&hColDesc, 1);
			  
			CServerIo::trace(3," ::Init - Force Direct Path Loading Handle to UCS2 Charset");
			m_sqlfields[n].csid=OCI_UCS2ID;
			status=OCIAttrSet((void *)hColDesc, OCI_DTYPE_PARAM,(void *)&m_sqlfields[n].csid,0,OCI_ATTR_CHARSET_ID,parent->m_hErr);
			CServerIo::trace(3," ::Init - Force Direct Path Loading Handle to UCS2 Charset (%d)",(int)status);
			if(!parent->CheckError(parent->m_hErr,status)
				CServerIo::trace(1,"Unable to set UCS2 character set \"%s\".",parent->ErrorString());
			OCIDescriptorFree((dvoid *)hColDesc, OCI_DTYPE_PARAM));
			*/
			}
			
			m_sqlfields[n].data = malloc((m_sqlfields[n].fldlen+2)+(is_string_data)?m_sqlfields[n].fldlen+2:0);
			memset(m_sqlfields[n].data,0,m_sqlfields[n].fldlen+(is_string_data)?m_sqlfields[n].fldlen+2:0);
			CServerIo::trace(3," ::Init -  OCIDefineByPos()");
			m_sqlfields[n].datalen[0]=0 /*m_sqlfields[n].fldlen*/ ;
			status=OCIDefineByPos(m_hStmt,&hDef,parent->m_hErr,n+1,(void **)m_sqlfields[n].data,m_sqlfields[n].fldlen,m_sqlfields[n].fldtype,0,(unsigned short *)&m_sqlfields[n].datalen,0,OCI_DEFAULT);
			CServerIo::trace(3," ::Init -  OCIDefineByPos()=%d,%d",status,(int)m_sqlfields[n].datalen[0]);
			if(!parent->CheckError(parent->m_hErr,status))
			{
				CServerIo::trace(1,"Unable to bind column %s due to error \"%s\".",(const char*)szaColPtr,parent->ErrorString());
				return false;
			}
			if (is_string_data)
			{
			  if (m_sqlfields[n].csid<OCI_UCS2ID)
			  {
			    m_sqlfields[n].csid=OCI_UCS2ID;
			    CServerIo::trace(3," ::Init - Define Handle to UCS2 Charset");
			    status=OCIAttrSet((void *)hDef, OCI_HTYPE_DEFINE,(void *)&m_sqlfields[n].csid,0,OCI_ATTR_CHARSET_ID,parent->m_hErr);
			    CServerIo::trace(3," ::Init - Define Handle to UCS2 Charset (%d)",(int)status);
			    if(!parent->CheckError(parent->m_hErr,status))
				CServerIo::trace(1,"Unable to set UCS2 character set \"%s\".",parent->ErrorString());
			  }
			}
			/*
			szaColPtr=NULL; ubaCol=0;
			OCIAttrGet(hParam,  OCI_HTYPE_DEFINE, (void**)&szaColPtr, &ubaCol, OCI_ATTR_NAME, parent->m_hErr);
			if (szaColPtr!=NULL)
			{
			CServerIo::trace(3,"  - ATTR_NAME (Define Handle) %s (%d).",szaColPtr,(int)ubaCol);
			m_sqlfields[n].name = cvs::wide((char *)szaColPtr);
			}
			else
			CServerIo::trace(3,"  - ATTR_NAME (Define Handle) NULL (%d).",(int)ubaCol);
			*/

			CServerIo::trace(3," ::Init -  complete");
		}
	}

	if (select)
	{
	CServerIo::trace(3,"COracleRecordset::Init -  OCIStmtExecute(%s,select=%d)",parent->m_bAutoCommit?"OCI_COMMIT_ON_SUCCESS":"OCI_DEFAULT",select?0:1);
	status=OCIStmtExecute(parent->m_hSvcCtx, hStmt, parent->m_hErr, select?0:1, 0, NULL, NULL, parent->m_bAutoCommit?OCI_COMMIT_ON_SUCCESS:OCI_DEFAULT);
	CServerIo::trace(3,"COracleRecordset::Init -  CheckError(%d)",(int)status);
	if(!parent->CheckError(parent->m_hErr,status))
		return false;
	}

	if(m_num_fields)
	{
		CServerIo::trace(3," ::Init -  m_num_fields=%d",(int)(m_num_fields));
		if(!Next() && !m_bEof)
			return false;
	}

	CServerIo::trace(3," ::Init -  return");
	return true;
}
Beispiel #13
0
/*
** Alloc buffers for column values.
*/
static int alloc_column_buffer (lua_State *L, cur_data *cur, int i) {
	/* column index ranges from 1 to numcols */
	/* C array index ranges from 0 to numcols-1 */
	column_data *col = &(cur->cols[i-1]);
	OCIParam *param;
	text *name;

	ASSERT (L, OCIParamGet (cur->stmthp, OCI_HTYPE_STMT, cur->errhp,
		(dvoid **)&param, i), cur->errhp);
	ASSERT (L, OCIAttrGet (param, OCI_DTYPE_PARAM,
		(dvoid *)&(name), (ub4 *)&(col->namelen),
		OCI_ATTR_NAME, cur->errhp), cur->errhp);
	copy_column_name (col, name);
	ASSERT (L, OCIAttrGet (param, OCI_DTYPE_PARAM,
		(dvoid *)&(col->type), (ub4 *)0, OCI_ATTR_DATA_TYPE,
		cur->errhp), cur->errhp);

	switch (col->type) {
		case SQLT_CHR:
		case SQLT_STR:
		case SQLT_VCS:
		case SQLT_AFC:
		case SQLT_AVC:
			ASSERT (L, OCIAttrGet (param, OCI_DTYPE_PARAM,
				(dvoid *)&(col->max), 0, OCI_ATTR_DATA_SIZE,
				cur->errhp), cur->errhp);
			col->val.s = calloc (col->max + 1, sizeof(col->val.s));
			ASSERT (L, OCIDefineByPos (cur->stmthp, &(col->define),
				cur->errhp, (ub4)i, col->val.s, col->max+1,
				SQLT_STR /*col->type*/, (dvoid *)&(col->null), (ub2 *)0,
				(ub2 *)0, (ub4) OCI_DEFAULT), cur->errhp);
			break;
		case SQLT_NUM:
		case SQLT_FLT:
		case SQLT_INT:
		/* case SQLT_UIN: */
			ASSERT (L, OCIDefineByPos (cur->stmthp, &(col->define),
				cur->errhp, (ub4)i, &(col->val.d), sizeof(col->val.d),
				SQLT_FLT, (dvoid *)&(col->null), (ub2 *)0,
				(ub2 *)0, (ub4) OCI_DEFAULT), cur->errhp);
			break;
		case SQLT_CLOB: {
			env_data *env;
			conn_data *conn;
			lua_rawgeti (L, LUA_REGISTRYINDEX, cur->conn);
			conn = (conn_data *)lua_touserdata (L, -1);
			lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env);
			env = (env_data *)lua_touserdata (L, -1);
			lua_pop (L, 2);
			ASSERT (L, OCIDescriptorAlloc (env->envhp, (dvoid *)&(col->val.s),
				OCI_DTYPE_LOB, (size_t)0, (dvoid **)0), cur->errhp);
			ASSERT (L, OCIDefineByPos (cur->stmthp, &(col->define),
				cur->errhp, (ub4)i, &(col->val.s), (sb4)sizeof(dvoid *),
				SQLT_CLOB, (dvoid *)&(col->null), (ub2 *)0, (ub2 *)0,
				OCI_DEFAULT), cur->errhp);
			break;
		}
		default:
			luaL_error (L, LUASQL_PREFIX"invalid type %d #%d", col->type, i);
			break;
	}
	return 0;
}
Beispiel #14
0
boolean OCI_ColumnDescribe
(
    OCI_Column     *col,
    OCI_Connection *con,
    OCI_Statement  *stmt,
    void           *handle,
    int             index,
    int             ptype
)
{
    void    *param    = NULL;
    boolean  res      = TRUE;

    /* get descriptor */

    if (OCI_DESC_COLLECTION == ptype)
    {
        OCI_CALL1
        (
            res, con, stmt,

            OCIAttrGet((dvoid *) handle, (ub4) OCI_DTYPE_PARAM, (dvoid *) &param,
                       (ub4 *) NULL, (ub4) OCI_ATTR_COLLECTION_ELEMENT, con->err)
        )
    }
    else
    {
        ub4 htype = (OCI_DESC_RESULTSET == ptype) ? OCI_HTYPE_STMT : OCI_DTYPE_PARAM;

        OCI_CALL1
        (
            res, con, stmt,

            OCIParamGet((dvoid *) handle, htype,  con->err, (void**) &param, (ub4) index)
        )
    }  

    /* sql code */

    OCI_CALL1
    (
        res, con, stmt,

        OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM, (dvoid *) &col->sqlcode,
                   (ub4 *) NULL, (ub4) OCI_ATTR_DATA_TYPE, con->err)
    )

    /* when the column is a record from a PL/SQL table, OCI returns an undocumented SQLT code */

#if OCI_VERSION_COMPILE >= OCI_12_1

    if (SQLT_UNDOCUMENTED_REC == col->sqlcode)
    {
        col->sqlcode = SQLT_REC;
    }

#endif

    /* size */

    OCI_CALL1
    (
        res, con, stmt,

        OCIAttrGet((dvoid *) param, (ub4)  OCI_DTYPE_PARAM, (dvoid *) &col->size,
                   (ub4 *) NULL, (ub4) OCI_ATTR_DATA_SIZE, con->err)
    )

    /* scale */

    OCI_CALL1
    (
        res, con, stmt,

        OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM, (dvoid *) &col->scale,
                   (ub4 *) NULL, (ub4) OCI_ATTR_SCALE, con->err)
    )

    /* precision */

    if (OCI_DESC_RESULTSET == ptype)
    {
        sb2 prec = 0;

        OCI_CALL1
        (
            res, con, stmt,

            OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM, (dvoid *) &prec,
                       (ub4 *) NULL, (ub4) OCI_ATTR_PRECISION, con->err)
        )

        col->prec = (sb2) prec;
    }
    else
    {
        ub1 prec = 0;

        OCI_CALL1
        (
            res, con, stmt,

            OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM, (dvoid *) &prec,
                       (ub4 *) NULL, (ub4) OCI_ATTR_PRECISION, con->err)
        )

        col->prec = (sb2) prec;
    }

    /* charset form */

    OCI_CALL1
    (
        res, con, stmt,

        OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM, (dvoid *) &col->csfrm,
                   (ub4 *) NULL, (ub4) OCI_ATTR_CHARSET_FORM, con->err)
    )

    /* type of column length for string based column */

#if OCI_VERSION_COMPILE >= OCI_9_2

    if ((OCILib.version_runtime >= OCI_9_2) && (con->ver_num >= OCI_9_2))
    {
        /* char used - no error checking because on Oracle 9.0, querying
                       this param that is not text based will cause an
                       error */

        OCI_CALL1
        (
            res, con, stmt,

            OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                       (dvoid *) &col->charused, (ub4 *) NULL,
                       (ub4) OCI_ATTR_CHAR_USED, con->err)
        )
    }

    /* char size */

    if (col->charused)
    {
        OCI_CALL1
        (
            res, con, stmt,

            OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                       (dvoid *) &col->charsize, (ub4 *) NULL,
                       (ub4) OCI_ATTR_CHAR_SIZE, con->err)
        )
    }

    if ((OCILib.version_runtime >= OCI_9_0) && (con->ver_num >= OCI_9_0))
    {
        /* fractional time precision for timestamps */

        if ( SQLT_TIMESTAMP     == col->sqlcode ||
             SQLT_TIMESTAMP_TZ  == col->sqlcode ||
             SQLT_TIMESTAMP_LTZ == col->sqlcode )
        {
            OCI_CALL1
            (
                res, con, stmt,

                OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                           (dvoid *) &col->prec, (ub4 *) NULL,
                           (ub4) OCI_ATTR_FSPRECISION, con->err)
            )
        }

        /* leading and fractional precision for interval */

        if (SQLT_INTERVAL_DS == col->sqlcode  || SQLT_INTERVAL_YM == col->sqlcode)
        {
            OCI_CALL1
            (
                res, con, stmt,

                OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                           (dvoid *) &col->prec, (ub4 *) NULL,
                           (ub4) OCI_ATTR_LFPRECISION, con->err)
            )

            OCI_CALL1
            (
                res, con, stmt,

                OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                           (dvoid *) &col->prec2, (ub4 *) NULL,
                           (ub4) OCI_ATTR_FSPRECISION, con->err)
            )
        }
    }

#endif

#if OCI_VERSION_COMPILE >= OCI_12_1

    if ((OCILib.version_runtime >= OCI_12_1) && (con->ver_num >= OCI_12_1))
    {
        if (ptype < OCI_DESC_TYPE)
        {
            ub8 value = 0;

            OCI_CALL1
            (
                res, con, stmt,

                OCIAttrGet((dvoid *) param, (ub4) OCI_DTYPE_PARAM,
                           (dvoid *) &value, (ub4 *) NULL,
                           (ub4) OCI_ATTR_COL_PROPERTIES, con->err)
            )

            if (value & OCI_ATTR_COL_PROPERTY_IS_IDENTITY)
            {
                col->props |=  OCI_CPF_IS_IDENTITY;
            }

            if (value & OCI_ATTR_COL_PROPERTY_IS_GEN_ALWAYS)
            {
                col->props |=  OCI_CPF_IS_GEN_ALWAYS;
            }

            if (value & OCI_ATTR_COL_PROPERTY_IS_GEN_BY_DEF_ON_NULL)
            {
                col->props |=  OCI_CPF_IS_GEN_BY_DEFAULT_ON_NULL;
            }
        }
    }
Beispiel #15
0
/******************************************************************************
 *                                                                            *
 * Function: zbx_db_vselect                                                   *
 *                                                                            *
 * Purpose: execute a select statement                                        *
 *                                                                            *
 * Return value: data, NULL (on error) or (DB_RESULT)ZBX_DB_DOWN              *
 *                                                                            *
 ******************************************************************************/
DB_RESULT	zbx_db_vselect(const char *fmt, va_list args)
{
	char		*sql = NULL;
	DB_RESULT	result = NULL;
	double		sec = 0;

#if defined(HAVE_IBM_DB2)
	int		i;
	SQLRETURN	ret = SQL_SUCCESS;
#elif defined(HAVE_ORACLE)
	sword		err = OCI_SUCCESS;
	ub4		counter;
#elif defined(HAVE_POSTGRESQL)
	char		*error = NULL;
#elif defined(HAVE_SQLITE3)
	int		ret = FAIL;
	char		*error = NULL;
#endif

	if (CONFIG_LOG_SLOW_QUERIES)
		sec = zbx_time();

	sql = zbx_dvsprintf(sql, fmt, args);

	zabbix_log(LOG_LEVEL_DEBUG, "query [txnlev:%d] [%s]", txn_level, sql);

#if defined(HAVE_IBM_DB2)
	result = zbx_malloc(result, sizeof(ZBX_IBM_DB2_RESULT));
	memset(result, 0, sizeof(ZBX_IBM_DB2_RESULT));

	/* allocate a statement handle */
	if (SUCCEED != zbx_ibm_db2_success(ret = SQLAllocHandle(SQL_HANDLE_STMT, ibm_db2.hdbc, &result->hstmt)))
		goto error;

	/* directly execute the statement */
	if (SUCCEED != zbx_ibm_db2_success(ret = SQLExecDirect(result->hstmt, (SQLCHAR *)sql, SQL_NTS)))
		goto error;

	/* identify the number of output columns */
	if (SUCCEED != zbx_ibm_db2_success(ret = SQLNumResultCols(result->hstmt, &result->ncolumn)))
		goto error;

	if (0 == result->ncolumn)
		goto error;

	result->nalloc = 0;
	result->values = zbx_malloc(result->values, sizeof(char *) * result->ncolumn);
	result->values_cli = zbx_malloc(result->values_cli, sizeof(char *) * result->ncolumn);
	result->values_len = zbx_malloc(result->values_len, sizeof(SQLINTEGER) * result->ncolumn);

	for (i = 0; i < result->ncolumn; i++)
	{
		/* get the display size for a column */
		if (SUCCEED != zbx_ibm_db2_success(ret = SQLColAttribute(result->hstmt, (SQLSMALLINT)(i + 1),
				SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, &result->values_len[i])))
		{
			goto error;
		}

		result->values_len[i] += 1; /* '\0'; */

		/* allocate memory to bind a column */
		result->values_cli[i] = zbx_malloc(NULL, result->values_len[i]);
		result->nalloc++;

		/* bind columns to program variables, converting all types to CHAR */
		if (SUCCEED != zbx_ibm_db2_success(ret = SQLBindCol(result->hstmt, (SQLSMALLINT)(i + 1),
				SQL_C_CHAR, result->values_cli[i], result->values_len[i], &result->values_len[i])))
		{
			goto error;
		}
	}
error:
	if (SUCCEED != zbx_ibm_db2_success(ret) || 0 == result->ncolumn)
	{
		zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);
		zbx_ibm_db2_log_errors(SQL_HANDLE_STMT, result->hstmt);

		IBM_DB2free_result(result);

		result = (SQL_CD_TRUE == IBM_DB2server_status() ? NULL : (DB_RESULT)ZBX_DB_DOWN);
	}
#elif defined(HAVE_MYSQL)
	if (NULL == conn)
	{
		zabbix_errlog(ERR_Z3003);
		result = NULL;
	}
	else
	{
		if (0 != mysql_query(conn, sql))
		{
			zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);
			switch (mysql_errno(conn))
			{
				case CR_CONN_HOST_ERROR:
				case CR_SERVER_GONE_ERROR:
				case CR_CONNECTION_ERROR:
				case CR_SERVER_LOST:
				case ER_SERVER_SHUTDOWN:
				case ER_ACCESS_DENIED_ERROR: /* wrong user or password */
				case ER_ILLEGAL_GRANT_FOR_TABLE: /* user without any privileges */
				case ER_TABLEACCESS_DENIED_ERROR:/* user without some privilege */
				case ER_UNKNOWN_ERROR:
					result = (DB_RESULT)ZBX_DB_DOWN;
					break;
				default:
					result = NULL;
					break;
			}
		}
		else
			result = mysql_store_result(conn);
	}
#elif defined(HAVE_ORACLE)
	result = zbx_malloc(NULL, sizeof(ZBX_OCI_DB_RESULT));
	memset(result, 0, sizeof(ZBX_OCI_DB_RESULT));

	err = OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&result->stmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);

	if (OCI_SUCCESS == err)
	{
		err = OCIStmtPrepare(result->stmthp, oracle.errhp, (text *)sql, (ub4)strlen((char *)sql),
				(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
	}

	if (OCI_SUCCESS == err)
	{
		err = OCIStmtExecute(oracle.svchp, result->stmthp, oracle.errhp, (ub4)0, (ub4)0,
				(CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_COMMIT_ON_SUCCESS);
	}

	if (OCI_SUCCESS == err)
	{
		/* get the number of columns in the query */
		err = OCIAttrGet((void *)result->stmthp, OCI_HTYPE_STMT, (void *)&result->ncolumn,
				  (ub4 *)0, OCI_ATTR_PARAM_COUNT, oracle.errhp);
	}

	if (OCI_SUCCESS != err)
		goto error;

	assert(0 < result->ncolumn);

	result->values = zbx_malloc(NULL, result->ncolumn * sizeof(char *));
	memset(result->values, 0, result->ncolumn * sizeof(char *));

	for (counter = 1; OCI_SUCCESS == err && counter <= result->ncolumn; counter++)
	{
		OCIParam	*parmdp = NULL;
		OCIDefine	*defnp = NULL;
		ub4		char_semantics;
		ub2		col_width;

		/* request a parameter descriptor in the select-list */
		err = OCIParamGet((void *)result->stmthp, OCI_HTYPE_STMT, oracle.errhp, (void **)&parmdp, (ub4)counter);

		if (OCI_SUCCESS == err)
		{
			/* retrieve the length semantics for the column */
			char_semantics = 0;
			err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&char_semantics, (ub4 *)0,
					(ub4)OCI_ATTR_CHAR_USED, (OCIError *)oracle.errhp);
		}

		if (OCI_SUCCESS == err)
		{
			col_width = 0;
			if (char_semantics)
			{
				/* retrieve the column width in characters */
				err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&col_width, (ub4 *)0,
						(ub4)OCI_ATTR_CHAR_SIZE, (OCIError *)oracle.errhp);
			}
			else
			{
				/* retrieve the column width in bytes */
				err = OCIAttrGet((void *)parmdp, (ub4)OCI_DTYPE_PARAM, (void *)&col_width, (ub4 *)0,
						(ub4)OCI_ATTR_DATA_SIZE, (OCIError *)oracle.errhp);
			}
		}
		col_width++;

		result->values[counter - 1] = zbx_malloc(NULL, col_width);
		memset(result->values[counter - 1], 0, col_width);

		if (OCI_SUCCESS == err)
		{
			/* represent any data as characters */
			err = OCIDefineByPos(result->stmthp, &defnp, oracle.errhp, counter,
					(dvoid *)result->values[counter - 1], col_width, SQLT_STR,
					(dvoid *)0, (ub2 *)0, (ub2 *)0, OCI_DEFAULT);
		}

		/* free cell descriptor */
		OCIDescriptorFree(parmdp, OCI_DTYPE_PARAM);
		parmdp = NULL;
	}

error:
	if (OCI_SUCCESS != err)
	{
		zabbix_errlog(ERR_Z3005, err, zbx_oci_error(err), sql);

		OCI_DBfree_result(result);

		result = (OCI_SERVER_NORMAL == OCI_DBserver_status() ? NULL : (DB_RESULT)ZBX_DB_DOWN);
	}
#elif defined(HAVE_POSTGRESQL)
	result = zbx_malloc(NULL, sizeof(ZBX_PG_DB_RESULT));
	result->pg_result = PQexec(conn, sql);
	result->values = NULL;
	result->cursor = 0;
	result->row_num = 0;

	if (NULL == result->pg_result)
		zabbix_errlog(ERR_Z3005, 0, "result is NULL", sql);

	if (PGRES_TUPLES_OK != PQresultStatus(result->pg_result))
	{
		error = zbx_dsprintf(error, "%s:%s",
				PQresStatus(PQresultStatus(result->pg_result)),
				PQresultErrorMessage(result->pg_result));
		zabbix_errlog(ERR_Z3005, 0, error, sql);
		zbx_free(error);

		PG_DBfree_result(result);
		result = (CONNECTION_OK == PQstatus(conn) ? NULL : (DB_RESULT)ZBX_DB_DOWN);
	}
	else	/* init rownum */
		result->row_num = PQntuples(result->pg_result);
#elif defined(HAVE_SQLITE3)
	if (0 == txn_level && PHP_MUTEX_OK != php_sem_acquire(&sqlite_access))
	{
		zabbix_log(LOG_LEVEL_CRIT, "ERROR: unable to create lock on SQLite database");
		exit(FAIL);
	}

	result = zbx_malloc(NULL, sizeof(ZBX_SQ_DB_RESULT));
	result->curow = 0;

lbl_get_table:
	if (SQLITE_OK != (ret = sqlite3_get_table(conn,sql, &result->data, &result->nrow, &result->ncolumn, &error)))
	{
		if (SQLITE_BUSY == ret)
			goto lbl_get_table;

		zabbix_errlog(ERR_Z3005, 0, error, sql);
		sqlite3_free(error);

		SQ_DBfree_result(result);

		switch (ret)
		{
			case SQLITE_ERROR:	/* SQL error or missing database; assuming SQL error, because if we
						   are this far into execution, zbx_db_connect() was successful */
			case SQLITE_NOMEM:	/* a malloc() failed */
			case SQLITE_MISMATCH:	/* data type mismatch */
				result = NULL;
				break;
			default:
				result = (DB_RESULT)ZBX_DB_DOWN;
				break;
		}
	}

	if (0 == txn_level)
		php_sem_release(&sqlite_access);
#endif	/* HAVE_SQLITE3 */

	if (CONFIG_LOG_SLOW_QUERIES)
	{
		sec = zbx_time() - sec;
		if (sec > (double)CONFIG_LOG_SLOW_QUERIES / 1000.0)
			zabbix_log(LOG_LEVEL_WARNING, "slow query: " ZBX_FS_DBL " sec, \"%s\"", sec, sql);
	}

	zbx_free(sql);
	return result;
}
Beispiel #16
0
static VALUE oci8_make_exc(dvoid *errhp, sword status, ub4 type, OCIStmt *stmthp, const char *file, int line)
{
    VALUE exc;
    char errmsg[128];
    sb4 errcode = -1;
    VALUE msg;
    VALUE parse_error_offset = Qnil;
    VALUE sql = Qnil;
    int rv;
    int numarg = 1;

    switch (status) {
    case OCI_ERROR:
        exc = eOCIError;
        msg = get_error_msg(errhp, type, "Error", &errcode);
        numarg = 4;
        break;
    case OCI_SUCCESS_WITH_INFO:
        exc = eOCISuccessWithInfo;
        msg = get_error_msg(errhp, type, "Error", &errcode);
        numarg = 4;
        break;
    case OCI_NO_DATA:
        exc = eOCINoData;
        msg = get_error_msg(errhp, type, "No Data", &errcode);
        numarg = 4;
        break;
    case OCI_INVALID_HANDLE:
        exc = eOCIInvalidHandle;
        msg = rb_usascii_str_new_cstr("Invalid Handle");
        break;
    case OCI_NEED_DATA:
        exc = eOCINeedData;
        msg = rb_usascii_str_new_cstr("Need Data");
        break;
    case OCI_STILL_EXECUTING:
        exc = eOCIStillExecuting;
        msg = rb_usascii_str_new_cstr("Still Executing");
        break;
    case OCI_CONTINUE:
        exc = eOCIContinue;
        msg = rb_usascii_str_new_cstr("Continue");
        break;
    default:
        sprintf(errmsg, "Unknown error (%d)", status);
        exc = eOCIException;
        msg = rb_usascii_str_new_cstr(errmsg);
    }
    if (stmthp != NULL) {
        ub2 offset;
        text *text;
        ub4 size;

        rv = OCIAttrGet(stmthp, OCI_HTYPE_STMT, &offset, 0, OCI_ATTR_PARSE_ERROR_OFFSET, errhp);
        if (rv == OCI_SUCCESS) {
            parse_error_offset = INT2FIX(offset);
        }
        rv = OCIAttrGet(stmthp, OCI_HTYPE_STMT, &text, &size, OCI_ATTR_STATEMENT, errhp);
        if (rv == OCI_SUCCESS) {
            sql = rb_external_str_new_with_enc(TO_CHARPTR(text), size, oci8_encoding);
        }
    }
    exc = rb_funcall(exc, oci8_id_new, numarg, msg, INT2FIX(errcode), sql, parse_error_offset);
    return set_backtrace(exc, file, line);
}
Beispiel #17
0
/******************************************************************************
 *                                                                            *
 * Function: zbx_db_connect                                                   *
 *                                                                            *
 * Purpose: connect to the database                                           *
 *                                                                            *
 * Return value: ZBX_DB_OK - succefully connected                             *
 *               ZBX_DB_DOWN - database is down                               *
 *               ZBX_DB_FAIL - failed to connect                              *
 *                                                                            *
 ******************************************************************************/
int	zbx_db_connect(char *host, char *user, char *password, char *dbname, char *dbschema, char *dbsocket, int port)
{
	int		ret = ZBX_DB_OK;
#if defined(HAVE_IBM_DB2)
	char		*connect = NULL;
#elif defined(HAVE_ORACLE)
	char		*connect = NULL;
	sword		err = OCI_SUCCESS;
#elif defined(HAVE_POSTGRESQL)
	char		*cport = NULL;
	DB_RESULT	result;
	DB_ROW		row;
#endif

	txn_init = 1;

#if defined(HAVE_IBM_DB2)
	connect = strdup("PROTOCOL=TCPIP;");
	if (NULL != dbname && '\0' != *dbname)
		connect = zbx_strdcatf(connect, "DATABASE=%s;", dbname);
	if (NULL != host && '\0' != *host)
		connect = zbx_strdcatf(connect, "HOSTNAME=%s;", host);
	if (0 != port)
		connect = zbx_strdcatf(connect, "PORT=%d;", port);
	if (NULL != user && '\0' != *user)
		connect = zbx_strdcatf(connect, "UID=%s;", user);
	if (NULL != password && '\0' != *password)
		connect = zbx_strdcatf(connect, "PWD=%s;", password);

	memset(&ibm_db2, 0, sizeof(ibm_db2));

	/* allocate an environment handle */
	if (SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &ibm_db2.henv)))
		ret = ZBX_DB_FAIL;

	/* set attribute to enable application to run as ODBC 3.0 application; recommended for pure IBM DB2 CLI, but not required */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetEnvAttr(ibm_db2.henv, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0)))
		ret = ZBX_DB_FAIL;

	/* allocate a database connection handle */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_DBC, ibm_db2.henv, &ibm_db2.hdbc)))
		ret = ZBX_DB_FAIL;

	/* connect to the database */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLDriverConnect(ibm_db2.hdbc, NULL, (SQLCHAR *)connect, SQL_NTS,
								NULL, 0, NULL, SQL_DRIVER_NOPROMPT)))
		ret = ZBX_DB_FAIL;

	/* set autocommit on */
  	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetConnectAttr(ibm_db2.hdbc, SQL_ATTR_AUTOCOMMIT,
								(SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_NTS)))
		ret = ZBX_DB_DOWN;

	/* we do not generate vendor escape clause sequences */
  	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLSetConnectAttr(ibm_db2.hdbc, SQL_ATTR_NOSCAN,
								(SQLPOINTER)SQL_NOSCAN_ON, SQL_NTS)))
		ret = ZBX_DB_DOWN;

	/* set current schema */
	if (NULL != dbschema && '\0' != *dbschema && ZBX_DB_OK == ret)
	{
		char	*dbschema_esc;

		dbschema_esc = DBdyn_escape_string(dbschema);
		DBexecute("set current schema='%s'", dbschema_esc);
		zbx_free(dbschema_esc);
	}

	/* output error information */
	if (ZBX_DB_OK != ret)
	{
		zbx_ibm_db2_log_errors(SQL_HANDLE_ENV, ibm_db2.henv);
		zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);

		zbx_db_close();
	}

	zbx_free(connect);
#elif defined(HAVE_MYSQL)
	conn = mysql_init(NULL);

	if (!mysql_real_connect(conn, host, user, password, dbname, port, dbsocket, CLIENT_MULTI_STATEMENTS))
	{
		zabbix_errlog(ERR_Z3001, dbname, mysql_errno(conn), mysql_error(conn));
		ret = ZBX_DB_FAIL;
	}

	if (ZBX_DB_OK == ret)
	{
		if (0 != mysql_select_db(conn, dbname))
		{
			zabbix_errlog(ERR_Z3001, dbname, mysql_errno(conn), mysql_error(conn));
			ret = ZBX_DB_FAIL;
		}
	}

	if (ZBX_DB_OK == ret)
	{
		DBexecute("SET NAMES utf8");
	}

	if (ZBX_DB_FAIL == ret)
	{
		switch (mysql_errno(conn))
		{
			case CR_CONN_HOST_ERROR:
			case CR_SERVER_GONE_ERROR:
			case CR_CONNECTION_ERROR:
			case CR_SERVER_LOST:
			case ER_SERVER_SHUTDOWN:
			case ER_ACCESS_DENIED_ERROR:		/* wrong user or password */
			case ER_ILLEGAL_GRANT_FOR_TABLE:	/* user without any privileges */
			case ER_TABLEACCESS_DENIED_ERROR:	/* user without some privilege */
			case ER_UNKNOWN_ERROR:
				ret = ZBX_DB_DOWN;
				break;
			default:
				break;
		}
	}
#elif defined(HAVE_ORACLE)
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
	if (NULL == getenv("NLS_LANG"))
		putenv("NLS_LANG=.UTF8");
#endif
	memset(&oracle, 0, sizeof(oracle));

	/* connection string format: [//]host[:port][/service name] */

	if (NULL != host && '\0' != *host)
	{
		connect = zbx_strdcatf(connect, "//%s", host);

		if (port)
			connect = zbx_strdcatf(connect, ":%d", port);

		if (dbname && *dbname)
			connect = zbx_strdcatf(connect, "/%s", dbname);
	}
	else
		ret = ZBX_DB_FAIL;

	if (ZBX_DB_OK == ret)
	{
		/* initialize environment */
		err = OCIEnvCreate((OCIEnv **)&oracle.envhp, (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 (OCI_SUCCESS != err)
		{
			zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
			ret = ZBX_DB_FAIL;
		}
	}

	if (ZBX_DB_OK == ret)
	{
		/* allocate an error handle */
		(void)OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&oracle.errhp, OCI_HTYPE_ERROR,
				(size_t)0, (dvoid **)0);

		/* get the session */
		err = OCILogon2(oracle.envhp, oracle.errhp, &oracle.svchp,
				(text *)user, (ub4)(NULL != user ? strlen(user) : 0),
				(text *)password, (ub4)(NULL != password ? strlen(password) : 0),
				(text *)connect, (ub4)strlen(connect),
				OCI_DEFAULT);

		if (OCI_SUCCESS != err)
		{
			zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
			ret = ZBX_DB_DOWN;
		}
		else
		{
			err = OCIAttrGet((void *)oracle.svchp, OCI_HTYPE_SVCCTX, (void *)&oracle.srvhp, (ub4 *)0,
					OCI_ATTR_SERVER, oracle.errhp);

			if (OCI_SUCCESS != err)
			{
				zabbix_errlog(ERR_Z3001, connect, err, zbx_oci_error(err));
				ret = ZBX_DB_DOWN;
			}
		}
	}

	zbx_free(connect);

	if (ZBX_DB_OK != ret)
		zbx_db_close();
#elif defined(HAVE_POSTGRESQL)
	if (0 != port)
		cport = zbx_dsprintf(cport, "%d", port);

	conn = PQsetdbLogin(host, cport, NULL, NULL, dbname, user, password);

	zbx_free(cport);

	/* check to see that the backend connection was successfully made */
	if (CONNECTION_OK != PQstatus(conn))
	{
		zabbix_errlog(ERR_Z3001, dbname, 0, PQerrorMessage(conn));
		ret = ZBX_DB_DOWN;
	}
	else
	{
		result = DBselect("select oid from pg_type where typname='bytea'");
		if (NULL != (row = DBfetch(result)))
			ZBX_PG_BYTEAOID = atoi(row[0]);
		DBfree_result(result);
	}

#ifdef HAVE_FUNCTION_PQSERVERVERSION
	ZBX_PG_SVERSION = PQserverVersion(conn);
	zabbix_log(LOG_LEVEL_DEBUG, "PostgreSQL Server version: %d", ZBX_PG_SVERSION);
#endif

	if (80100 <= ZBX_PG_SVERSION)
	{
		/* disable "nonstandard use of \' in a string literal" warning */
		DBexecute("set escape_string_warning to off");
	}

	if (90000 <= ZBX_PG_SVERSION)
	{
		/* change the output format for values of type bytea from hex (the default) to escape */
		DBexecute("set bytea_output=escape");
	}
#elif defined(HAVE_SQLITE3)
#ifdef HAVE_FUNCTION_SQLITE3_OPEN_V2
	if (SQLITE_OK != sqlite3_open_v2(dbname, &conn, SQLITE_OPEN_READWRITE, NULL))
#else
	if (SQLITE_OK != sqlite3_open(dbname, &conn))
#endif
	{
		zabbix_errlog(ERR_Z3001, dbname, 0, sqlite3_errmsg(conn));
		sqlite3_close(conn);
		ret = ZBX_DB_DOWN;
	}
	else
	{
		char	*p, *path;

		/* do not return SQLITE_BUSY immediately, wait for N ms */
		sqlite3_busy_timeout(conn, SEC_PER_MIN * 1000);

		path = strdup(dbname);
		if (NULL != (p = strrchr(path, '/')))
			*++p = '\0';
		else
			*path = '\0';

		DBexecute("PRAGMA synchronous = 0"); /* OFF */
		DBexecute("PRAGMA temp_store = 2"); /* MEMORY */
		DBexecute("PRAGMA temp_store_directory = '%s'", path);

		zbx_free(path);
	}
#endif	/* HAVE_SQLITE3 */

	txn_init = 0;

	return ret;
}
Beispiel #18
0
GSQLCursorState 
oracle_cursor_open_bind_by_name (GSQLCursor *cursor, GList *args)
{
	GSQL_TRACE_FUNC;

	GSQLEOracleCursor	*spec_cursor;
	GSQLEOracleSession	*spec_session;
	GSQLEOracleVariable *spec_var;
	GSQLVariable		*var;
	GList *vlist = args;
	GList *vlist_value;
	GType vtype;
	guint  n, var_count=0;
	sword ret;
	OCIParam *param;
	static OCIBind *bindhp = 0;
	unsigned char op[2000];
	gint i;
	gchar *holder;
	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;
		
		/* bind by name means first item are name of bind point - it is always are string (gchar *) */
		if (vtype != G_TYPE_STRING)
		{
			GSQL_DEBUG ("Wrong GSQL_CURSOR_BIND_BY_NAME usage");
			return GSQL_CURSOR_STATE_ERROR;
		}
		
		vlist = g_list_next (vlist);
		holder = g_strdup ( (gchar *) vlist->data);
		
		vlist = g_list_next (vlist);
		vtype = (GType) vlist->data;
		vlist = g_list_next (vlist);
		
		switch (vtype)
		{
			case G_TYPE_STRING:
			case G_TYPE_POINTER:
			
				ret = OCIBindByName (spec_cursor->statement, &bindhp, spec_cursor->errhp,
							(CONST text *) holder,-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);
				GSQL_DEBUG ("Bind by name: [\'%s\' = %s] [ret = %d]", holder, vlist->data, ret);
				if (oracle_check_error (cursor, ret))
				{
					GSQL_DEBUG ("bind error");
				}
				
				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;
				
		}
		
		g_free (holder);
		
		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**) &param, 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;

}
Beispiel #19
0
static VALUE attr_get_common(int argc, VALUE *argv, VALUE self, enum datatype datatype)
{
    oci8_base_t *base = DATA_PTR(self);
    VALUE attr_type;
    VALUE strict;
    union {
        ub1 ub1val;
        ub2 ub2val;
        ub4 ub4val;
        ub8 ub8val;
        sb1 sb1val;
        sb2 sb2val;
        sb4 sb4val;
        sb8 sb8val;
        boolean booleanval;
        char *charptr;
        ub1 *ub1ptr;
    } v;
    ub4 size = 0;
    sword rv;

    v.ub8val = MAGIC_NUMBER;
    rb_scan_args(argc, argv, "11", &attr_type, &strict);
    if (argc == 1) {
        strict = Qtrue;
    }
    Check_Type(attr_type, T_FIXNUM);
    rv = OCIAttrGet(base->hp.ptr, base->type, &v, &size, FIX2INT(attr_type), oci8_errhp);
    if (!RTEST(strict)) {
        if (rv == OCI_ERROR && oci8_get_error_code(oci8_errhp) == 24328) {
			/* ignore ORA-24328: illegal attribute value */
            return Qnil;
        }
    }
    chker2(rv, base);
    switch (datatype) {
        OCINumber onum;
        static VALUE cOraDate = Qnil;
    case DATATYPE_UB1:
        return INT2FIX(v.ub1val);
    case DATATYPE_UB2:
        return INT2FIX(v.ub2val);
    case DATATYPE_UB4:
        return UINT2NUM(v.ub4val);
    case DATATYPE_UB8:
        return ULL2NUM(v.ub8val);
    case DATATYPE_SB1:
        return INT2FIX(v.sb1val);
    case DATATYPE_SB2:
        return INT2FIX(v.sb2val);
    case DATATYPE_SB4:
        return INT2NUM(v.sb4val);
    case DATATYPE_SB8:
        return LL2NUM(v.sb8val);
    case DATATYPE_BOOLEAN:
        return v.booleanval ? Qtrue : Qfalse;
    case DATATYPE_STRING:
        if (size == 0 && !RTEST(strict)) {
            return Qnil;
        }
        return rb_external_str_new_with_enc(v.charptr, size, oci8_encoding);
    case DATATYPE_BINARY:
        return rb_tainted_str_new(v.charptr, size);
    case DATATYPE_INTEGER:
        if (size > sizeof(onum.OCINumberPart) - 1) {
            rb_raise(rb_eRuntimeError, "Too long size %u", size);
        }
        memset(&onum, 0, sizeof(onum));
        onum.OCINumberPart[0] = size;
        memcpy(&onum.OCINumberPart[1], v.ub1ptr, size);
        return oci8_make_integer(&onum, oci8_errhp);
    case DATATYPE_ORADATE:
        if (NIL_P(cOraDate))
            cOraDate = rb_eval_string("OraDate");
        return rb_funcall(cOraDate, oci8_id_new, 6,
                          INT2FIX((v.ub1ptr[0] - 100) * 100 + (v.ub1ptr[1] - 100)),
                          INT2FIX(v.ub1ptr[2]),
                          INT2FIX(v.ub1ptr[3]),
                          INT2FIX(v.ub1ptr[4] - 1),
                          INT2FIX(v.ub1ptr[5] - 1),
                          INT2FIX(v.ub1ptr[6] - 1));
    }
    return Qnil;
}
Beispiel #20
0
static gboolean
oracle_sql_exec(GSQLCursor *cursor)
{
	GSQL_TRACE_FUNC;

	sword ret;
	int num_iters = 0;
	unsigned char mess[2000];
	GSQLEOracleSession *spec_session;
	GSQLEOracleCursor  *spec_cursor;
	gint param;

	
	spec_session = (GSQLEOracleSession *) cursor->session->spec;
	spec_cursor = (GSQLEOracleCursor *) cursor->spec;
    
	/* FIXME. 
	iters (IN)
		For non-SELECT statements, the number of times this statement is executed is equal to
		iters - rowoff.
		For SELECT statements, if iters is nonzero, then defines must have been done for the
		statement handle. The execution fetches iters rows into these predefined buffers and
		prefetches more rows depending upon the prefetch row count. If you do not know
		how many rows the SELECT statement will retrieve, set iters to zero.
		This function returns an error if iters=0 for non-SELECT statements.

		Note: For array DML operations, set iters <= 32767 to get better performance.
	*/

	num_iters = (spec_cursor->statement_type != OCI_STMT_SELECT) ? 1: 0;
	
	if ((cursor->scrollable) && (num_iters))
		param = OCI_STMT_SCROLLABLE_READONLY;
	else
		param = OCI_DEFAULT;


	ret = OCIStmtExecute(spec_session->svchp, spec_cursor->statement,
							spec_cursor->errhp, num_iters, 0, 0, 0, 
							param);

	
	if (oracle_check_error (cursor, ret))
	{
		 return FALSE;
	}
	
	OCIAttrGet(spec_cursor->statement, OCI_HTYPE_STMT,
				(dvoid*) &(spec_cursor->row_count), 0, OCI_ATTR_ROW_COUNT,
				spec_cursor->errhp);
	
	 switch (spec_cursor->statement_type)
	{
		case OCI_STMT_UPDATE:
			cursor->stmt_type = GSQL_CURSOR_STMT_UPDATE;
			cursor->stmt_affected_rows = spec_cursor->row_count;
			break;
			
		case OCI_STMT_DELETE:
			cursor->stmt_type = GSQL_CURSOR_STMT_DELETE;
			cursor->stmt_affected_rows = spec_cursor->row_count;
			break;
		
		case OCI_STMT_INSERT:
			cursor->stmt_type = GSQL_CURSOR_STMT_INSERT;
			cursor->stmt_affected_rows = spec_cursor->row_count;
			break;

		case OCI_STMT_SELECT:
			cursor->stmt_type = GSQL_CURSOR_STMT_SELECT;
			cursor->stmt_affected_rows = 0;
			break;
		
		case OCI_STMT_CREATE:
			cursor->stmt_type = GSQL_CURSOR_STMT_CREATE;
			cursor->stmt_affected_rows = 0;
			break;
			
		case OCI_STMT_DROP:
			cursor->stmt_type = GSQL_CURSOR_STMT_DROP;
			cursor->stmt_affected_rows = 0;
			break;
			
		case OCI_STMT_ALTER:
			cursor->stmt_type = GSQL_CURSOR_STMT_ALTER;
			cursor->stmt_affected_rows = 0;
			break;
			
		case OCI_STMT_BEGIN:
		case OCI_STMT_DECLARE:
			cursor->stmt_type = GSQL_CURSOR_STMT_EXEC;
			cursor->stmt_affected_rows = 0;
			break;
			
		default:
			GSQL_DEBUG ("Oracle engine: internal error occured. Unknown statement type.");
			return FALSE;
			
	}

	if (spec_session->dbms_output)
		oracle_dbms_output (cursor);

	return TRUE;
};
Beispiel #21
0
/*
 * Get and convert columns from a result. Define handlers and buffers
 */
static int get_columns(ora_con_t* con, db_res_t* _r, OCIStmt* _c, dmap_t* _d)
{
    OCIParam *param;
    size_t tsz;
    ub4 i, n;
    sword status;

    status = OCIAttrGet(_c, OCI_HTYPE_STMT, &n, NULL, OCI_ATTR_PARAM_COUNT,
                        con->errhp);

    if (status != OCI_SUCCESS) {
        LM_ERR("driver: %s\n", db_oracle_error(con, status));
        return -1;
    }

    if (!n) {
        LM_ERR("no columns\n");
        return -2;
    }

    if (n >= MAX_DEF_HANDLES) {
        LM_ERR("too many res. Rebuild with MAX_DEF_HANDLES >= %u\n", n);
        return -3;
    }

    if (db_allocate_columns(_r, n) != 0) {
        LM_ERR("could not allocate columns");
        return -4;
    }
    memset(RES_NAMES(_r), 0, sizeof(db_key_t) * n);

    RES_COL_N(_r) = n;

    tsz = 0;
    memset(_d->defh, 0, sizeof(_d->defh[0]) * n);
    for (i = 0; i < n; i++) {
        ub4 len;
        ub2 dtype;

        status = OCIParamGet(_c, OCI_HTYPE_STMT, con->errhp,
                             (dvoid**)(dvoid*)&param, i+1);
        if (status != OCI_SUCCESS) goto ora_err;

        {
            text* name;
            status = OCIAttrGet(param, OCI_DTYPE_PARAM,
                                (dvoid**)(dvoid*)&name,	&len, OCI_ATTR_NAME,
                                con->errhp);
            if (status != OCI_SUCCESS) goto ora_err;
            RES_NAMES(_r)[i]->s = (char*)pkg_malloc(len+1);
            if (!RES_NAMES(_r)[i]->s) {
                db_free_columns(_r);
                LM_ERR("no private memory left\n");
                return -5;
            }
            RES_NAMES(_r)[i]->len = len;
            memcpy(RES_NAMES(_r)[i]->s, name, len);
            RES_NAMES(_r)[i]->s[len] = '\0';
        }

        status = OCIAttrGet(param, OCI_DTYPE_PARAM,
                            (dvoid**)(dvoid*)&dtype, NULL, OCI_ATTR_DATA_TYPE,
                            con->errhp);
        if (status != OCI_SUCCESS) goto ora_err;

        switch (dtype) {
        case SQLT_UIN:		/* unsigned integer */
set_bitmap:
            LM_DBG("use DB_BITMAP type");
            RES_TYPES(_r)[i] = DB_BITMAP;
            len = sizeof(VAL_BITMAP((db_val_t*)NULL));
            break;

        case SQLT_INT:		/* (ORANET TYPE) integer */
set_int:
            LM_DBG("use DB_INT result type");
            RES_TYPES(_r)[i] = DB_INT;
            len = sizeof(VAL_INT((db_val_t*)NULL));
            break;

//		case SQLT_LNG:		/* long */
        case SQLT_VNU:		/* NUM with preceding length byte */
        case SQLT_NUM:		/* (ORANET TYPE) oracle numeric */
            len = 0; /* PRECISION is ub1 */
            status = OCIAttrGet(param, OCI_DTYPE_PARAM,
                                (dvoid**)(dvoid*)&len, NULL, OCI_ATTR_PRECISION,
                                con->errhp);
            if (status != OCI_SUCCESS) goto ora_err;
            if (len <= 11) {
                sb1 sc;
                status = OCIAttrGet(param, OCI_DTYPE_PARAM,
                                    (dvoid**)(dvoid*)&sc, NULL,
                                    OCI_ATTR_SCALE, con->errhp);
                if (status != OCI_SUCCESS) goto ora_err;
                if (!sc) {
                    dtype = SQLT_INT;
                    if (len != 11) goto set_int;
                    dtype = SQLT_UIN;
                    goto set_bitmap;
                }
            }
        case SQLT_FLT:		/* (ORANET TYPE) Floating point number */
        case SQLT_BFLOAT:       /* Native Binary float*/
        case SQLT_BDOUBLE:	/* NAtive binary double */
        case SQLT_IBFLOAT:	/* binary float canonical */
        case SQLT_IBDOUBLE:	/* binary double canonical */
        case SQLT_PDN:		/* (ORANET TYPE) Packed Decimal Numeric */
            LM_DBG("use DB_DOUBLE result type");
            RES_TYPES(_r)[i] = DB_DOUBLE;
            len = sizeof(VAL_DOUBLE((db_val_t*)NULL));
            dtype = SQLT_FLT;
            break;

//		case SQLT_TIME:		/* TIME */
//		case SQLT_TIME_TZ:	/* TIME WITH TIME ZONE */
        case SQLT_DATE:		/* ANSI Date */
        case SQLT_DAT:		/* date in oracle format */
        case SQLT_ODT:		/* OCIDate type */
        case SQLT_TIMESTAMP:	/* TIMESTAMP */
        case SQLT_TIMESTAMP_TZ:	/* TIMESTAMP WITH TIME ZONE */
        case SQLT_TIMESTAMP_LTZ:/* TIMESTAMP WITH LOCAL TZ */
//		case SQLT_INTERVAL_YM:	/* INTERVAL YEAR TO MONTH */
//		case SQLT_INTERVAL_DS:	/* INTERVAL DAY TO SECOND */
            LM_DBG("use DB_DATETIME result type");
            RES_TYPES(_r)[i] = DB_DATETIME;
            len = sizeof(OCIDate);
            dtype = SQLT_ODT;
            break;

        case SQLT_CLOB:		/* character lob */
        case SQLT_BLOB:		/* binary lob */
//		case SQLT_BFILEE:	/* binary file lob */
//		case SQLT_CFILEE:	/* character file lob */
//		case SQLT_BIN:		/* binary data(DTYBIN) */
//		case SQLT_LBI:		/* long binary */
            LM_DBG("use DB_BLOB result type");
            RES_TYPES(_r)[i] = DB_BLOB;
            goto dyn_str;

        case SQLT_CHR:		/* (ORANET TYPE) character string */
        case SQLT_STR:		/* zero terminated string */
        case SQLT_VST:		/* OCIString type */
        case SQLT_VCS:		/* Variable character string */
        case SQLT_AFC:		/* Ansi fixed char */
        case SQLT_AVC:		/* Ansi Var char */
//		case SQLT_RID:		/* rowid */
            LM_DBG("use DB_STR result type");
            RES_TYPES(_r)[i] = DB_STR;
dyn_str:
            dtype = SQLT_CHR;
            len = 0; /* DATA_SIZE is ub2 */
            status = OCIAttrGet(param, OCI_DTYPE_PARAM,
                                (dvoid**)(dvoid*)&len, NULL, OCI_ATTR_DATA_SIZE,
                                con->errhp);
            if (status != OCI_SUCCESS) goto ora_err;
            if (len >= 4000) {
                LM_DBG("use DB_BLOB result type");
                RES_TYPES(_r)[i] = DB_BLOB;
            }
            ++len;
            break;

        default:
            LM_ERR("unsupported datatype %d\n", dtype);
            goto stop_load;
        }
        _d->ilen[i] = (ub2)len;
        _d->pv[i].v = st_buf + tsz;
        tsz += len;
        status = OCIDefineByPos(_c, &_d->defh[i], con->errhp, i+1,
                                _d->pv[i].v, len, dtype, &_d->ind[i],
                                &_d->len[i], NULL, OCI_DEFAULT);
        if (status != OCI_SUCCESS) goto ora_err;
    }

#if STATIC_BUF_LEN < 65536
#error
#endif
    if (tsz > 65536) {
        LM_ERR("Row size exceed 65K. IOB's are not supported");
        goto stop_load;
    }
    return 0;

ora_err:
    LM_ERR("driver: %s\n", db_oracle_error(con, status));
stop_load:
    db_free_columns(_r);
    return -6;
}
Beispiel #22
0
GSQLCursorState 
oracle_cursor_open (GSQLCursor *cursor)
{
	GSQL_TRACE_FUNC;

	GSQLEOracleCursor	*spec_cursor;
	GSQLEOracleSession	*spec_session;
	GSQLEOracleVariable *spec_var;
	GSQLVariable		*var;
	gint var_count;
	sword ret;
	OCIParam *param;
	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)) || 
		(!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**) &param, 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;
}
Beispiel #23
0
static int o_read_database (o_database_t *db) /* {{{ */
{
  size_t i;
  int status;

  if (db->oci_service_context != NULL)
  {
    OCIServer *server_handle;
    ub4 connection_status;

    server_handle = NULL;
    status = OCIAttrGet ((void *) db->oci_service_context, OCI_HTYPE_SVCCTX, 
        (void *) &server_handle, /* size pointer = */ NULL,
        OCI_ATTR_SERVER, oci_error);
    if (status != OCI_SUCCESS)
    {
      o_report_error ("o_read_database", db->name, NULL, "OCIAttrGet",
          oci_error);
      return (-1);
    }

    if (server_handle == NULL)
    {
      connection_status = OCI_SERVER_NOT_CONNECTED;
    }
    else /* if (server_handle != NULL) */
    {
      connection_status = 0;
      status = OCIAttrGet ((void *) server_handle, OCI_HTYPE_SERVER,
          (void *) &connection_status, /* size pointer = */ NULL,
          OCI_ATTR_SERVER_STATUS, oci_error);
      if (status != OCI_SUCCESS)
      {
        o_report_error ("o_read_database", db->name, NULL, "OCIAttrGet",
            oci_error);
        return (-1);
      }
    }

    if (connection_status != OCI_SERVER_NORMAL)
    {
      INFO ("oracle plugin: Connection to %s lost. Trying to reconnect.",
          db->name);
      OCIHandleFree (db->oci_service_context, OCI_HTYPE_SVCCTX);
      db->oci_service_context = NULL;
    }
  } /* if (db->oci_service_context != NULL) */

  if (db->oci_service_context == NULL)
  {
    status = OCILogon (oci_env, oci_error,
        &db->oci_service_context,
        (OraText *) db->username, (ub4) strlen (db->username),
        (OraText *) db->password, (ub4) strlen (db->password),
        (OraText *) db->connect_id, (ub4) strlen (db->connect_id));
    if ((status != OCI_SUCCESS) && (status != OCI_SUCCESS_WITH_INFO))
    {
      char errfunc[256];

      ssnprintf (errfunc, sizeof (errfunc), "OCILogon(\"%s\")", db->connect_id);

      o_report_error ("o_read_database", db->name, NULL, errfunc, oci_error);
      DEBUG ("oracle plugin: OCILogon (%s): db->oci_service_context = %p;",
          db->connect_id, db->oci_service_context);
      db->oci_service_context = NULL;
      return (-1);
    }
    else if (status == OCI_SUCCESS_WITH_INFO)
    {
      /* TODO: Print NOTIFY message. */
    }
    assert (db->oci_service_context != NULL);
  }

  DEBUG ("oracle plugin: o_read_database: db->connect_id = %s; db->oci_service_context = %p;",
      db->connect_id, db->oci_service_context);

  for (i = 0; i < db->queries_num; i++)
    o_read_database_query (db, db->queries[i], db->q_prep_areas[i]);

  return (0);
} /* }}} int o_read_database */
OracleConnection::ObjectType OracleConnection::ReadSPDescriptionFromDB( const String &command, Anything &desc )
{
	StartTrace(OracleConnection.ReadSPDescriptionFromDB);

	String strErr( "ReadSPDescriptionFromDB: " );

	MemChecker aCheckerLocal( "OracleConnection.ReadSPDescriptionFromDB", getEnvironment().getAllocator() );
	MemChecker aCheckerGlobal( "OracleConnection.ReadSPDescriptionFromDB", coast::storage::Global());

	sword attrStat;
	DscHandleType aDschp;
	if ( checkError( ( attrStat = OCIHandleAlloc( getEnvironment().EnvHandle(), aDschp.getVoidAddr(),
								  OCI_HTYPE_DESCRIBE, 0, 0 ) ) ) ) {
		throw OracleException( *this, attrStat );
	}
	Trace("after HandleAlloc, local allocator:" << reinterpret_cast<long>(getEnvironment().getAllocator()));
	Trace("after HandleAlloc, global allocator:" << reinterpret_cast<long>(coast::storage::Global()));

	OCIParam *parmh( 0 );
	ObjectType aStmtType = DescribeObjectByName(command, aDschp, parmh);
	if ( aStmtType == TYPE_SYN ) {
		Trace("as we identified a synonym, we need to collect the scheme name and the referenced object name to ask for description");
		text *name(0);
		ub4 namelen(0);
		String strSchemaName;
		attrStat = OCIAttrGet( (dvoid *) parmh, OCI_DTYPE_PARAM, (dvoid *) &name, (ub4 *) &namelen, OCI_ATTR_SCHEMA_NAME, ErrorHandle() );
		if ( checkError( ( attrStat ) ) ) {
			throw OracleException( *this, attrStat );
		}
		strSchemaName.Append(String( (char *) name, namelen ));
		Trace("SchemaName: " << strSchemaName);

		attrStat = OCIAttrGet( (dvoid *) parmh, OCI_DTYPE_PARAM, (dvoid *) &name, (ub4 *) &namelen, OCI_ATTR_NAME, ErrorHandle() );
		if ( checkError( ( attrStat ) ) ) {
			throw OracleException( *this, attrStat );
		}
		if ( strSchemaName.Length() ) {
			strSchemaName.Append('.');
		}
		strSchemaName.Append(String( (char *) name, namelen ));

		Trace("trying to get descriptions for " << strSchemaName);
		aStmtType = DescribeObjectByName(strSchemaName, aDschp, parmh);
	}
	bool bIsFunction = ( aStmtType == TYPE_FUNC );

	Trace("get the number of arguments and the arg list for stored " << (bIsFunction ? "function" : "procedure"))
	OCIParam *arglst( 0 );
	ub2 numargs = 0;
	if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) parmh, OCI_DTYPE_PARAM, (dvoid *) &arglst, (ub4 *) 0,
								  OCI_ATTR_LIST_ARGUMENTS, ErrorHandle() ) ) ) ) {
		throw OracleException( *this, attrStat );
	}
	if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) arglst, OCI_DTYPE_PARAM, (dvoid *) &numargs, (ub4 *) 0,
								  OCI_ATTR_NUM_PARAMS, ErrorHandle() ) ) ) ) {
		throw OracleException( *this, attrStat );
	}
	Trace(String("number of arguments: ") << numargs);

	OCIParam *arg( 0 );
	text *name;
	ub4 namelen;
	ub2 dtype;
	OCITypeParamMode iomode;
	ub4 data_len;

	// For a procedure, we begin with i = 1; for a function, we begin with i = 0.
	int start = 0;
	int end = numargs;
	if ( !bIsFunction ) {
		++start;
		++end;
	}

	for ( int i = start; i < end; ++i ) {
		if ( checkError( ( attrStat = OCIParamGet( (dvoid *) arglst, OCI_DTYPE_PARAM, ErrorHandle(), (dvoid **) &arg,
									  (ub4) i ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
		namelen = 0;
		name = 0;
		data_len = 0;

		if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) arg, OCI_DTYPE_PARAM, (dvoid *) &dtype, (ub4 *) 0,
									  OCI_ATTR_DATA_TYPE, ErrorHandle() ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
		Trace("Data type: " << dtype)

		if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) arg, OCI_DTYPE_PARAM, (dvoid *) &name, (ub4 *) &namelen,
									  OCI_ATTR_NAME, ErrorHandle() ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
		String strName( (char *) name, namelen );
		// the first param of a function is the return param
		if ( bIsFunction && i == start ) {
			strName = command;
			Trace("Name: " << strName)
		}

		// 0 = IN (OCI_TYPEPARAM_IN), 1 = OUT (OCI_TYPEPARAM_OUT), 2 = IN/OUT (OCI_TYPEPARAM_INOUT)
		if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) arg, OCI_DTYPE_PARAM, (dvoid *) &iomode, (ub4 *) 0,
									  OCI_ATTR_IOMODE, ErrorHandle() ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
		Trace("IO type: " << iomode)

		if ( checkError( ( attrStat = OCIAttrGet( (dvoid *) arg, OCI_DTYPE_PARAM, (dvoid *) &data_len, (ub4 *) 0,
									  OCI_ATTR_DATA_SIZE, ErrorHandle() ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
		Trace("Size: " << (int)data_len)

		Anything param( desc.GetAllocator() );
		param["Name"] = strName;
		param["Type"] = dtype;
		param["Length"] = (int) data_len;
		param["IoMode"] = iomode;
		param["Idx"] = (long) ( bIsFunction ? i + 1 : i );
		desc.Append( param );
		if ( checkError( ( attrStat = OCIDescriptorFree( arg, OCI_DTYPE_PARAM ) ) ) ) {
			throw OracleException( *this, attrStat );
		}
	}
Beispiel #25
0
CPLErr 
OGROCISession::GetParmInfo( OCIParam *hParmDesc, OGRFieldDefn *poOGRDefn,
                            ub2 *pnOCIType, ub4 *pnOCILen )

{
    ub2 nOCIType, nOCILen;
    ub4 nColLen;
    char *pszColName;
    char szTermColName[128];
    
/* -------------------------------------------------------------------- */
/*      Get basic parameter details.                                    */
/* -------------------------------------------------------------------- */
    if( Failed( 
        OCIAttrGet( hParmDesc, OCI_DTYPE_PARAM, 
                    (dvoid **)&nOCIType, 0, OCI_ATTR_DATA_TYPE, hError ),
        "OCIAttrGet(Type)" ) )
        return CE_Failure;

    if( Failed( 
        OCIAttrGet( hParmDesc, OCI_DTYPE_PARAM, 
                    (dvoid **)&nOCILen, 0, OCI_ATTR_DATA_SIZE, hError ),
        "OCIAttrGet(Size)" ) )
        return CE_Failure;

    if( Failed(
        OCIAttrGet( hParmDesc, OCI_DTYPE_PARAM, (dvoid **)&pszColName,
                    &nColLen, OCI_ATTR_NAME, hError ), 
        "OCIAttrGet(Name)") )
        return CE_Failure;
    
    if( nColLen >= sizeof(szTermColName) )                              
    {
        CPLError( CE_Failure, CPLE_AppDefined, 
                  "Column length (%d) longer than column name buffer (%d) in\n"
                  "OGROCISession::GetParmInfo()", 
                  nColLen, (int) sizeof(szTermColName) );
        return CE_Failure;
    }

    strncpy( szTermColName, pszColName, nColLen );
    szTermColName[nColLen] = '\0';
    
    poOGRDefn->SetName( szTermColName );

/* -------------------------------------------------------------------- */
/*      Attempt to classify as an OGRType.                              */
/* -------------------------------------------------------------------- */
    switch( nOCIType )
    {
        case SQLT_CHR:
        case SQLT_AFC: /* CHAR(), NCHAR() */
            poOGRDefn->SetType( OFTString );
            if( nOCILen <= 4000 )
                poOGRDefn->SetWidth( nOCILen );
            break;

        case SQLT_NUM:
        {
            // NOTE: OCI docs say this should be ub1 type, but we have
            // determined that oracle is actually returning a short so we
            // use that type and try to compensate for possible problems by
            // initializing, and dividing by 256 if it is large. 
            unsigned short byPrecision = 0;
            sb1  nScale;

            if( Failed(
                OCIAttrGet( hParmDesc, OCI_DTYPE_PARAM, (dvoid **)&byPrecision,
                            0, OCI_ATTR_PRECISION, hError ), 
                "OCIAttrGet(Precision)" ) )
                return CE_Failure;
            if( Failed(
                OCIAttrGet( hParmDesc, OCI_DTYPE_PARAM, (dvoid **)&nScale,
                            0, OCI_ATTR_SCALE, hError ), 
                "OCIAttrGet(Scale)") )
                return CE_Failure;
#ifdef notdef
            CPLDebug( "OCI", "%s: Scale=%d, Precision=%d", 
                      szTermColName, nScale, byPrecision );
#endif
            if( byPrecision > 255 )
                byPrecision = byPrecision / 256;

            if( nScale < 0 )
                poOGRDefn->SetType( OFTReal );
            else if( nScale > 0 )
            {
                poOGRDefn->SetType( OFTReal );
                poOGRDefn->SetWidth( byPrecision );
                poOGRDefn->SetPrecision( nScale );
            }
            else if( byPrecision < 38 )
            {
                poOGRDefn->SetType( OFTInteger );
                poOGRDefn->SetWidth( byPrecision );
            }
            else
            {
                poOGRDefn->SetType( OFTInteger );
            }
        }
        break;

        case SQLT_DAT:
        case SQLT_DATE:
            poOGRDefn->SetType( OFTDate );
            break;
        case SQLT_TIMESTAMP:
        case SQLT_TIMESTAMP_TZ:
        case SQLT_TIMESTAMP_LTZ:
        case SQLT_TIME:
        case SQLT_TIME_TZ:
            poOGRDefn->SetType( OFTDateTime );
            break;

        case SQLT_RID:
        case SQLT_BIN:
        case SQLT_LBI:
        case 111: /* REF */
        case SQLT_CLOB:
        case SQLT_BLOB:
        case SQLT_FILE:
        case 208: /* UROWID */
            poOGRDefn->SetType( OFTBinary );
            break;

        default:
            poOGRDefn->SetType( OFTBinary );
            break;
    }

    if( pnOCIType != NULL )
        *pnOCIType = nOCIType;

    if( pnOCILen != NULL )
        *pnOCILen = nOCILen;

    return CE_None;
}
Beispiel #26
0
// 数据库查询操作
int COracleDB::oracle_select( const char *sql, OracleResult *sql_result )
{
	int ret = DB_ERR_SUCCESS;

	if ( _handle == NULL )
		return DB_ERR_NOCONNECTION;

	ORACLE_HANDLE* handle = ( ORACLE_HANDLE* ) _handle;

	sb2 ind[MAX_COL];
	ub2 collen[MAX_COL];

	text * colbuf[MAX_COL];
	OCIDefine *defhp[MAX_COL];

	int i = 0;
	int status = 0;
	ub4 col_num = 0;

	OCIParam * colhp;

	while ( 1 ) {
		status = OCIStmtPrepare( handle->stmthp, handle->errhp, ( text * ) sql, ( ub4 ) strlen( ( const char * ) sql ),
				( ub4 ) OCI_NTV_SYNTAX, ( ub4 ) OCI_DEFAULT );
		if ( status != OCI_STILL_EXECUTING )
			break;

		my_usleep();
	}

	time_t t1 = time( NULL );

	while ( 1 ) {
		status = OCIStmtExecute( handle->svchp, handle->stmthp, handle->errhp, 0, 0, NULL, NULL, OCI_DEFAULT );

		if ( status != OCI_STILL_EXECUTING )
			break;

		if ( time( NULL ) - t1 > 60 ) {
			// timeout
			ret = DB_ERR_TIMEOUT;
			break;
		}

		my_usleep();

	}

	if ( ret == DB_ERR_SUCCESS && status != OCI_SUCCESS_WITH_INFO && status != OCI_SUCCESS ) {
		if ( status == OCI_NO_DATA ) {

		} else {
			int errcode = checkerr( handle->errhp, status, _errinfo, sql );

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

		}
	}

	if ( ret != DB_ERR_SUCCESS )
		return ret;

	while ( 1 ) {
		status = OCIAttrGet( handle->stmthp, OCI_HTYPE_STMT, & col_num, 0, OCI_ATTR_PARAM_COUNT, handle->errhp );

		if ( status != OCI_STILL_EXECUTING )
			break;

		my_usleep();

	}

	if ( status ) {
		int errcode = checkerr( handle->errhp, status, _errinfo, sql );

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

	if ( ret != DB_ERR_SUCCESS )
		return ret;

	for ( i = 1; i <= (int)col_num ; i ++ ) {
		while ( 1 ) {
			status = OCIParamGet( handle->stmthp, OCI_HTYPE_STMT, handle->errhp, ( dvoid ** ) & colhp, i );

			if ( status != OCI_STILL_EXECUTING )
				break;

			my_usleep();
		}

		text *name;
		ub4 namelen = 128;

		while ( 1 ) {
			status = OCIAttrGet( ( dvoid* ) colhp, OCI_DTYPE_PARAM, & name, & namelen, OCI_ATTR_NAME, handle->errhp );

			if ( status != OCI_STILL_EXECUTING )
				break;

			my_usleep();
		}

		while ( 1 ) {
			status = OCIAttrGet( ( dvoid* ) colhp, OCI_DTYPE_PARAM, & collen[i - 1], 0, OCI_ATTR_DATA_SIZE,
					handle->errhp );

			if ( status != OCI_STILL_EXECUTING )
				break;

			my_usleep();
		}

		colbuf[i - 1] = ( text * ) malloc( ( int ) collen[i - 1] + 1 );

		while ( 1 ) {
			status = OCIDefineByPos( handle->stmthp, & defhp[i - 1], handle->errhp, i, ( ub1* ) colbuf[i - 1],
					collen[i - 1] + 1, SQLT_STR, & ind[i - 1], 0, ( ub2* ) 0, OCI_DEFAULT );

			if ( status != OCI_STILL_EXECUTING )
				break;

			my_usleep();
		}

	}

	int j = 0;

	t1 = time( NULL );

	int count = 0;

	// 设置取数据列数
	sql_result->SetColumn( col_num );

	while ( 1 ) {
		status = OCIStmtFetch( handle->stmthp, handle->errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT );
		if ( status == OCI_NO_DATA ) {
			break;
		}
		if ( status == OCI_STILL_EXECUTING ) {
			if ( time( NULL ) - t1 > 60 ) {
				ret = DB_ERR_TIMEOUT;
				break;
			}

			count ++;
			if ( count > 100 ) {
				my_usleep();
				count = 0;
			}
			continue;
		}

		int errcode = 0;
		errcode = checkerr( handle->errhp, status, _errinfo, sql );
		if ( 0 == errcode || 1406 == errcode ) {
			for ( i = 0; i < (int)col_num ; i ++ ) {
				if ( ind[i] == - 1 )
					colbuf[i][0] = '\0';

				sql_result->AddValue( j, i, ( const char * ) colbuf[i] );
			}
			j ++;

			t1 = time( NULL );

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

			break;
		}
	}

	// 释放所有列名称
	for ( i = 0; i < (int)col_num ; i ++ ) {
		if ( colbuf[i] )
			free( colbuf[i] );
	}

	return ret;
}
Beispiel #27
0
static int yada_oracle__exec(yada_t *_yada, char *sqlstr, int sqlstr_len)
{
  char errbuf[1024];
  sb4 errcode;
  ub4 rows;
  OCIStmt *stmt = NULL;


  /* check database connection */
  if(!_yada->_mod->env && !_yada->connect(_yada, NULL, NULL))
    return(0);

  if(!sqlstr_len)
    sqlstr_len = strlen(sqlstr);

  /* prepare the statement */
#ifdef OBSOLETE_OCI
  /* allocate error handle */
  if(OCIHandleAlloc(_yada->_mod->env, (void *)&stmt,
   OCI_HTYPE_STMT, 0, NULL) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->env, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ENV);
    _yada_set_err(_yada, errcode, errbuf);
    return(0);
    }

  if(OCIStmtPrepare(stmt, _yada->_mod->err, (text*)sqlstr,
   (ub4)sqlstr_len, OCI_NTV_SYNTAX, OCI_DEFAULT) != OCI_SUCCESS)
    {
#else
  if(OCIStmtPrepare2(_yada->_mod->ctx, &stmt, _yada->_mod->err, (text*)sqlstr,
   (ub4)sqlstr_len, NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT) != OCI_SUCCESS)
    {
#endif
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    return(-1);
    }

  /* execute the statement */
  if(OCIStmtExecute(_yada->_mod->ctx, stmt, _yada->_mod->err,
   (ub4)1, (ub4)0, NULL, NULL, OCI_DEFAULT) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    _yada->disconnect(_yada);
    return(-1);
    }

  /* determine number of affected rows */
  if(OCIAttrGet(stmt, OCI_HTYPE_STMT, &rows, NULL,
   OCI_ATTR_ROW_COUNT, _yada->_mod->err) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    _yada->disconnect(_yada);
    return(-1);
    }

  /* commit if not in a transaction */
  if(!(_yada->_mod->flags & ORAF_INTRX))
    yada_oracle_commit(_yada);

  /* release prepared statement */
  OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
  OCIHandleFree(stmt, OCI_HTYPE_STMT);
  return(rows);
}

/******************************************************************************/
/** prepare a statement
 * @return YADA_RESULT resource on success
 */

static yada_rc_t* yada_oracle__query(yada_t *_yada, char *sqlstr,
 int sqlstr_len)
{
  char errbuf[1024];
  sb4 errcode;
  yada_rc_t *_yrc;
  OCIStmt *stmt = NULL;


  /* check database connection */
  if(!_yada->_mod->env && !_yada->connect(_yada, NULL, NULL))
    return(0);

  if(!sqlstr_len)
    sqlstr_len = strlen(sqlstr);

  /* prepare the statement */
#ifdef OBSOLETE_OCI
  /* allocate error handle */
  if(OCIHandleAlloc(_yada->_mod->env, (void*)&stmt,
   OCI_HTYPE_STMT, 0, NULL) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->env, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ENV);
    _yada_set_err(_yada, errcode, errbuf);
    return(NULL);
    }

  if(OCIStmtPrepare(stmt, _yada->_mod->err, (text*)sqlstr,
   (ub4)sqlstr_len, OCI_NTV_SYNTAX, OCI_DEFAULT) != OCI_SUCCESS)
    {
#else
  if(OCIStmtPrepare2(_yada->_mod->ctx, &stmt, _yada->_mod->err, (text*)sqlstr,
   (ub4)sqlstr_len, NULL, 0, OCI_NTV_SYNTAX, OCI_DEFAULT) != OCI_SUCCESS)
    {
#endif
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    return(NULL);
    }

  /* execute the statement */
  if(OCIStmtExecute(_yada->_mod->ctx, stmt, _yada->_mod->err,
   (ub4)0, (ub4)0, NULL, NULL, OCI_DEFAULT) != OCI_SUCCESS)
    {
    OCIErrorGet(_yada->_mod->err, 1, NULL, &errcode, errbuf, sizeof(errbuf),
     OCI_HTYPE_ERROR);
    _yada_set_err(_yada, errcode, errbuf);
    OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    _yada->disconnect(_yada);
    return(NULL);
    }

  /* return statement handle */
  if(!(_yrc = _yada_rc_new(_yada)))
    {
    OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    _yada_set_yadaerr(_yada, YADA_ENOMEM);
    return(NULL);
    }
  _yrc->t = YADA_RESULT;

  /* alocate space for extended info */
  if(!(_yrc->data = malloc(sizeof(extinfo))))
    {
    _yada->free(_yada, _yrc);
    OCIStmtRelease(stmt, _yada->_mod->err, NULL, 0, OCI_DEFAULT);
    OCIHandleFree(stmt, OCI_HTYPE_STMT);
    _yada_set_yadaerr(_yada, YADA_ENOMEM);
    return(NULL);
    }
  ((extinfo*)_yrc->data)->stmt = stmt;
  ((extinfo*)_yrc->data)->bind = 1;
  ((extinfo*)_yrc->data)->invalid = 0;
  return(_yrc);
}

/******************************************************************************/
/** free prepared statement
 */

static void yada_oracle_free_result(yada_t *_yada, yada_rc_t *_yrc)
{
  if(!((extinfo*)_yrc->data)->invalid)
    {
    OCIStmtRelease(((extinfo*)_yrc->data)->stmt, _yada->_mod->err,
     NULL, 0, OCI_DEFAULT);
    OCIHandleFree(((extinfo*)_yrc->data)->stmt, OCI_HTYPE_STMT);
    }

  free(_yrc->data);
}

/******************************************************************************/
/** free bindset
 */

static void yada_oracle_free_bindset(yada_t *_yada, yada_rc_t *_yrc)
{
  int i;
  yada_bindset_t *bs;
  bindset_ele_t *bse;


  bs = _yrc->data;

  /* free any allocated buffers */
  for(i=0, bse=bs->ele; i<bs->eles; bse++, i++)
    {
    switch(bse->t)
      {
    /************************************************/
    case -'b':
    /************************************************/
      /* free allocated buffer */
      free(bse->var.buf);
    /* fallthrough */
    /************************************************/
    case 'b':
    /************************************************/
      /* skip length element */
      bse++;
      break;
    /************************************************/
    case 'l':
    case -'l':
    /************************************************/
      free(bse->tmp);
      break;
    /************************************************/
    case -'s':
    case -'e':
    case -'v':
    /************************************************/
      /* free allocated buffer */
      free(bse->var.buf);
      break;
    /************************************************/
      }
    } /* foreach(binding) */

  /* call generic free function */
  yada_free_bindset(_yada, _yrc);
}
Beispiel #28
0
/*
 * Execute SQL statement. For non-select statements only.
 */
int	zbx_db_vexecute(const char *fmt, va_list args)
{
	char	*sql = NULL;
	int	ret = ZBX_DB_OK;
	double	sec = 0;

#if defined(HAVE_IBM_DB2)
	SQLHANDLE	hstmt = 0;
	SQLRETURN	ret1;
	SQLLEN		row1;
	SQLLEN		rows = 0;
#elif defined(HAVE_MYSQL)
	int		status;
#elif defined(HAVE_ORACLE)
	OCIStmt		*stmthp = NULL;
	sword		err = OCI_SUCCESS;
#elif defined(HAVE_POSTGRESQL)
	PGresult	*result;
	char		*error = NULL;
#elif defined(HAVE_SQLITE3)
	int		err;
	char		*error = NULL;
#endif

	if (CONFIG_LOG_SLOW_QUERIES)
		sec = zbx_time();

	sql = fmt;
	//zabbix_log(LOG_LEVEL_DEBUG,"vexecute: %s",sql);

	if (0 == txn_init && 0 == txn_level)
		zabbix_log(LOG_LEVEL_DEBUG, "query without transaction detected");

	zabbix_log(LOG_LEVEL_DEBUG, "query [txnlev:%d] [%s]", txn_level, sql);

#if defined(HAVE_IBM_DB2)
	/* allocate a statement handle */
	if (SUCCEED != zbx_ibm_db2_success(SQLAllocHandle(SQL_HANDLE_STMT, ibm_db2.hdbc, &hstmt)))
		ret = ZBX_DB_DOWN;

	/* directly execute the statement; returns SQL_NO_DATA_FOUND when no rows were affected */
  	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success_ext(SQLExecDirect(hstmt, (SQLCHAR *)sql, SQL_NTS)))
		ret = ZBX_DB_DOWN;

	/* get number of affected rows */
	if (ZBX_DB_OK == ret && SUCCEED != zbx_ibm_db2_success(SQLRowCount(hstmt, &rows)))
		ret = ZBX_DB_DOWN;

	/* process other SQL statements in the batch */
	while (ZBX_DB_OK == ret && SUCCEED == zbx_ibm_db2_success(ret1 = SQLMoreResults(hstmt)))
	{
		if (SUCCEED != zbx_ibm_db2_success(SQLRowCount(hstmt, &row1)))
			ret = ZBX_DB_DOWN;
		else
			rows += row1;
	}

	if (ZBX_DB_OK == ret && SQL_NO_DATA_FOUND != ret1)
		ret = ZBX_DB_DOWN;

	if (ZBX_DB_OK != ret)
	{
		zbx_ibm_db2_log_errors(SQL_HANDLE_DBC, ibm_db2.hdbc);
		zbx_ibm_db2_log_errors(SQL_HANDLE_STMT, hstmt);

		ret = (SQL_CD_TRUE == IBM_DB2server_status() ? ZBX_DB_FAIL : ZBX_DB_DOWN);
	}
	else if (0 <= rows)
	{
		ret = (int)rows;
	}

	if (hstmt)
		SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
#elif defined(HAVE_MYSQL)
	if (NULL == conn)
	{
		zabbix_errlog(ERR_Z3003);
		ret = ZBX_DB_FAIL;
	}
	else
	{
		if (0 != (status = mysql_query(conn, sql)))
		{
			zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);

			switch (mysql_errno(conn))
			{
				case CR_CONN_HOST_ERROR:
				case CR_SERVER_GONE_ERROR:
				case CR_CONNECTION_ERROR:
				case CR_SERVER_LOST:
				case ER_SERVER_SHUTDOWN:
				case ER_ACCESS_DENIED_ERROR: /* wrong user or password */
				case ER_ILLEGAL_GRANT_FOR_TABLE: /* user without any privileges */
				case ER_TABLEACCESS_DENIED_ERROR:/* user without some privilege */
				case ER_UNKNOWN_ERROR:
					ret = ZBX_DB_DOWN;
					break;
				default:
					ret = ZBX_DB_FAIL;
					break;
			}
		}
		else
		{
			do
			{
				if (0 != mysql_field_count(conn))
				{
					zabbix_log(LOG_LEVEL_DEBUG, "cannot retrieve result set");
					break;
				}
				else
					ret += (int)mysql_affected_rows(conn);

				/* more results? -1 = no, >0 = error, 0 = yes (keep looping) */
				if (0 < (status = mysql_next_result(conn)))
					zabbix_errlog(ERR_Z3005, mysql_errno(conn), mysql_error(conn), sql);
			}
			while (0 == status);
		}
	}
#elif defined(HAVE_ORACLE)
	err = OCIHandleAlloc((dvoid *)oracle.envhp, (dvoid **)&stmthp, OCI_HTYPE_STMT, (size_t)0, (dvoid **)0);

	if (OCI_SUCCESS == err)
	{
		err = OCIStmtPrepare(stmthp, oracle.errhp, (text *)sql, (ub4)strlen((char *)sql),
				(ub4)OCI_NTV_SYNTAX, (ub4)OCI_DEFAULT);
	}

	if (OCI_SUCCESS == err)
	{
		err = OCIStmtExecute(oracle.svchp, stmthp, oracle.errhp, (ub4)1, (ub4)0,
				(CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, OCI_COMMIT_ON_SUCCESS);

		if (OCI_SUCCESS == err)
		{
			ub4	nrows = 0;

			err = OCIAttrGet((void *)stmthp, OCI_HTYPE_STMT, (ub4 *)&nrows,
					  (ub4 *)0, OCI_ATTR_ROW_COUNT, oracle.errhp);

			ret = nrows;
		}
	}

	if (OCI_SUCCESS != err)
	{
		zabbix_errlog(ERR_Z3005, err, zbx_oci_error(err), sql);
		ret = (OCI_SERVER_NORMAL == OCI_DBserver_status() ? ZBX_DB_FAIL : ZBX_DB_DOWN);
	}

	if (NULL != stmthp)
	{
		(void)OCIHandleFree((dvoid *)stmthp, OCI_HTYPE_STMT);
		stmthp = NULL;
	}
#elif defined(HAVE_POSTGRESQL)
	result = PQexec(conn,sql);

	if (NULL == result)
	{
		zabbix_errlog(ERR_Z3005, 0, "result is NULL", sql);
		ret = (CONNECTION_OK == PQstatus(conn) ? ZBX_DB_FAIL : ZBX_DB_DOWN);
	}
	else if (PGRES_COMMAND_OK != PQresultStatus(result))
	{
		error = zbx_dsprintf(error, "%s:%s",
				PQresStatus(PQresultStatus(result)),
				PQresultErrorMessage(result));
		zabbix_errlog(ERR_Z3005, 0, error, sql);
		zbx_free(error);

		ret = (CONNECTION_OK == PQstatus(conn) ? ZBX_DB_FAIL : ZBX_DB_DOWN);
	}

	if (ZBX_DB_OK == ret)
		ret = atoi(PQcmdTuples(result));

	PQclear(result);
#elif defined(HAVE_SQLITE3)
	if (0 == txn_level && PHP_MUTEX_OK != php_sem_acquire(&sqlite_access))
	{
		zabbix_log(LOG_LEVEL_CRIT, "ERROR: unable to create lock on SQLite database");
		exit(FAIL);
	}

lbl_exec:
	if (SQLITE_OK != (err = sqlite3_exec(conn, sql, NULL, 0, &error)))
	{
		if (SQLITE_BUSY == err)
			goto lbl_exec;

		zabbix_errlog(ERR_Z3005, 0, error, sql);
		sqlite3_free(error);

		switch (err)
		{
			case SQLITE_ERROR:	/* SQL error or missing database; assuming SQL error, because if we
						   are this far into execution, zbx_db_connect() was successful */
			case SQLITE_NOMEM:	/* A malloc() failed */
			case SQLITE_TOOBIG:	/* String or BLOB exceeds size limit */
			case SQLITE_CONSTRAINT:	/* Abort due to constraint violation */
			case SQLITE_MISMATCH:	/* Data type mismatch */
				ret = ZBX_DB_FAIL;
				break;
			default:
				ret = ZBX_DB_DOWN;
				break;
		}
	}

	if (ZBX_DB_OK == ret)
		ret = sqlite3_changes(conn);

	if (0 == txn_level)
		php_sem_release(&sqlite_access);
#endif	/* HAVE_SQLITE3 */

	if (CONFIG_LOG_SLOW_QUERIES)
	{
		sec = zbx_time() - sec;
		if (sec > (double)CONFIG_LOG_SLOW_QUERIES / 1000.0)
			zabbix_log(LOG_LEVEL_WARNING, "slow query: " ZBX_FS_DBL " sec, \"%s\"", sec, sql);
	}


	return ret;
}
void OD_Set_SQL_in_cursor(sLONG_PTR *pResult, PackagePtr pParams)
{
	C_LONGINT Param1;
	C_TEXT Param2;
	C_LONGINT Param3;	
	C_LONGINT returnValue;
	
	Param1.fromParamAtIndex(pParams, 1);
	Param2.fromParamAtIndex(pParams, 2);
	Param3.fromParamAtIndex(pParams, 3);
	
	uint32_t cursorId = Param1.getIntValue();
	
	sword err = 0;
	
	ORACLE_SQL_CURSOR *cursor = _cursorGetAndCheckInactive(cursorId);
	
	if(cursor)
	{
		sessionInfo *session = _sessionGet(cursor->sessionId);
		
		if(session)
		{
			_cursorClearBind(session, cursor);
			
			//convert 4D bindings to oracle bindings
			CUTF8String sql, substr;
			Param2.copyUTF8String(&sql);
			
			size_t start, end, pos; 
			end = 0;
			pos = 0;
			
			C_TEXT variableName;
			PA_Variable variable;
			
			CUTF8String parsedSql;
			
			ORACLE_SQL_SUBSTITUTION_LIST substitutions;
			//ORACLE_SQL_BIND_TYPE_LIST isByName;
			ORACLE_SQL_BIND_NAME_LIST names;
			
			C_TEXT temp;
			CUTF16String u16;
			
			for(start = sql.find((const uint8_t *)"<<"); start != CUTF8String::npos; start = sql.find((const uint8_t *)"<<", end))
			{
				end = sql.find((const uint8_t *)">>", start);
				if(end != CUTF8String::npos)
				{
					start += 2;//length of "<<"
					substr = sql.substr(start, end-start);
					
					variableName.setUTF8String(&substr);
					variable = PA_GetVariable((PA_Unichar *)variableName.getUTF16StringPtr());
					
					parsedSql += sql.substr(pos, start - pos - 2);
					parsedSql += (const uint8_t *)":";
					
					if(substr.length()){
						
						parsedSql += substr;
						//isByName.push_back(true);
						temp.setUTF8String(&substr);
						temp.copyUTF16String(&u16);
						
					}else{
						
						char buf[10];
						size_t len;
						
						len = sprintf(buf,"%d", (int)substitutions.size() + 1);
						parsedSql += CUTF8String((const uint8_t *)buf, len);
						//isByName.push_back(false);
						u16.clear();
						
					}
					
					pos = end + 2;//length of ">>"
					
					names.push_back(u16);
					substitutions.push_back(variable);	
					
				}
				
			}
			
			//remaining text
			parsedSql += sql.substr(pos);			

			temp.setUTF8String(&parsedSql);
			temp.copyUTF16String(&cursor->sql);
			
			cursor->substitutions = substitutions;
//			cursor->isByName = isByName;
			cursor->names = names;
			
			size_t count = substitutions.size();
			
			_cursorResize(session, cursor, count);

			unsigned int sql_type = 0;
			
			ub4 language = OCI_NTV_SYNTAX;
			
			switch (Param3.getIntValue())
			{
				case 2:
					language = OCI_V7_SYNTAX;
					break;

				case 3:
					language = OCI_V8_SYNTAX;
					break;					
			}
			
			err = OCIStmtPrepare(cursor->stmtp, cursor->errhp, 
						   (CONST text *)cursor->sql.c_str(), 
						   (ub4)cursor->sql.length() * sizeof(PA_Unichar),								 
						   language,
						   OCI_DEFAULT);
			
			//in characters or in number of bytes, depending on the encoding
			//http://docs.oracle.com/cd/B10500_01/appdev.920/a96584/oci16ms6.htm
			
			if(!err)
			{
				err = OCIAttrGet(cursor->stmtp, OCI_HTYPE_STMT, (dvoid *)&sql_type, 0, OCI_ATTR_STMT_TYPE, cursor->errhp);
				//http://docs.oracle.com/cd/B10500_01/appdev.920/a96584/oci15r20.htm#443771
				
				if(!err)
				{
					cursor->sql_type = sql_type;
					//http://docs.oracle.com/cd/E14072_01/appdev.112/e10646/oci04sql.htm#CIHEHCEJ	
					
					switch (sql_type)
					{
						case OCI_STMT_SELECT:
							cursor->isTowardsSQL.assign(count, false);//SELECT is towards 4D
							break;					
						default:
							cursor->isTowardsSQL.assign(count, true);//INSERT is towards SQL
							break;
					}
					
					returnValue.setIntValue(1);

				}

			}
			
			if(err)
			{
				_errorInfoSet(0, cursor->errhp, cursor->sessionId, cursorId, false, PA_GetCurrentProcessNumber(), 0);	
				returnValue.setIntValue(err);
			}
			
		}

	}
		
	returnValue.setReturn(pResult);	
	
}
Beispiel #30
0
/*
   Execute a SQL command that returns a result table, and and bind the
   default row.  Also check and bind the global array of bind variables
   (if any).
*/
int
cllExecSqlWithResult( icatSessionStruct *icss, int *stmtNum, const char *sql ) {
    OCIEnv           *p_env;
    OCISvcCtx        *p_svc;
    static OCIStmt          *p_statement;
    static OCIDefine        *p_dfn    = ( OCIDefine * ) 0;
    int stat, stat2, i, j;
    char *cptr;
    char sqlConverted[MAX_SQL_SIZE];

    icatStmtStrct *myStatement;
    int statementNumber;

    int counter;
    OCIParam     *mypard = ( OCIParam * ) 0;
    ub2 dtype;
    ub2 col_width;
    ub4 char_semantics;
    OraText  *colName;

    static int columnLength[MAX_TOKEN];
    static sb2 indicator[MAX_TOKEN];

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

    i = convertSqlToOra( sql, sqlConverted );
    if ( i != 0 ) {
        rodsLog( LOG_ERROR, "cllExecSqlWithResult: SQL too long" );
        return CAT_OCI_ERROR;
    }

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

    /* set up our statement */
    statementNumber = -1;
    for ( i = 0; i < MAX_NUM_OF_CONCURRENT_STMTS && statementNumber < 0; i++ ) {
        if ( icss->stmtPtr[i] == 0 ) {
            statementNumber = i;
        }
    }
    if ( statementNumber < 0 ) {
        rodsLog( LOG_ERROR,
                 "cllExecSqlWithResult: too many concurrent statements" );
        return -2;
    }

    myStatement = ( icatStmtStrct * )malloc( sizeof( icatStmtStrct ) );
    icss->stmtPtr[statementNumber] = myStatement;
    myStatement->numOfCols = 0;

    myStatement->stmtPtr = p_statement;

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

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

    logTheBindVariables( 0 );
    rodsLogSql( sqlConverted );

    /* Execute statement */
    stat = OCIStmtExecute( p_svc, p_statement, p_err, ( ub4 ) 0, ( ub4 ) 0,
                           ( CONST OCISnapshot * ) NULL, ( OCISnapshot * ) NULL,
                           OCI_DEFAULT );

    stat2 = logExecuteStatus( stat, sqlConverted, "cllExecSqlWithResult" );

    if ( stat2 ) {
        return stat2;
    }

    *stmtNum = statementNumber; /* return index to statement handle */

    /* get the number of columns and width of the columns */

    /* Request a parameter descriptor for position 1 in the select-list */
    counter = 1;
    stat = OCIParamGet( ( dvoid * )p_statement, OCI_HTYPE_STMT, p_err,
                        ( dvoid ** )&mypard, ( ub4 ) counter );

    /* Loop only if a descriptor was successfully retrieved for
       current position, starting at 1 */

    while ( stat == OCI_SUCCESS ) {
        /* Retrieve the datatype attribute */
        stat = OCIAttrGet( ( dvoid* ) mypard, ( ub4 ) OCI_DTYPE_PARAM,
                           ( dvoid* ) &dtype, ( ub4 * ) 0, ( ub4 ) OCI_ATTR_DATA_TYPE,
                           ( OCIError * ) p_err );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlWithResult: OCIAttrGet failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }

        /* Retrieve the length semantics for the column */
        char_semantics = 0;
        stat = OCIAttrGet( ( dvoid* ) mypard, ( ub4 ) OCI_DTYPE_PARAM,
                           ( dvoid* ) &char_semantics, ( ub4 * ) 0,
                           ( ub4 ) OCI_ATTR_CHAR_USED,
                           ( OCIError * ) p_err );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlWithResult: OCIAttrGet failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }

        /* Retrieve the column width in characters */
        col_width = 0;
        if ( char_semantics ) {
            stat = OCIAttrGet( ( dvoid* ) mypard, ( ub4 ) OCI_DTYPE_PARAM,
                               ( dvoid* ) &col_width, ( ub4 * ) 0,
                               ( ub4 ) OCI_ATTR_CHAR_SIZE,
                               ( OCIError * ) p_err );
        }
        else {
            stat = OCIAttrGet( ( dvoid* ) mypard, ( ub4 ) OCI_DTYPE_PARAM,
                               ( dvoid* ) &col_width, ( ub4 * ) 0,
                               ( ub4 ) OCI_ATTR_DATA_SIZE,
                               ( OCIError * ) p_err );
        }
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlWithResult: OCIAttrGet failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }

        /* get the col name */
        stat = OCIAttrGet( ( dvoid* ) mypard, ( ub4 ) OCI_DTYPE_PARAM,
                           &colName, ( ub4 * ) 0,
                           ( ub4 ) OCI_ATTR_NAME,
                           ( OCIError * ) p_err );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlWithResult: OCIAttrGet failed: %d",
                     stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }

        columnLength[counter] = col_width;

        i = counter - 1;
        columnLength[i] = col_width;

        if ( strlen( ( char * )colName ) > col_width ) {
            columnLength[i] = strlen( ( char* )colName );
        }

        myStatement->resultColName[i] = ( char * )malloc( ( int )columnLength[i] + 2 );
        strncpy( myStatement->resultColName[i],
                 ( char * )colName, columnLength[i] );

        /* Big cludge/hack, but it looks like an OCI bug when the colName
           is exactly 8 bytes (or something).  Anyway, when the column name
           is "RESC_NETRESC_DEF_PATH" it's actually the running together of
           two names, so the code below corrects it. */
        if ( strcmp( myStatement->resultColName[i], "RESC_NETRESC_DEF_PATH" ) == 0 ) {
            strncpy( myStatement->resultColName[i],
                     "RESC_NET", columnLength[i] );
        }
        /* Second case, second cludge/hack */
        if ( strcmp( myStatement->resultColName[i],
                     "USER_DISTIN_NAMEUSER_INFO" ) == 0 ) {
            strncpy( myStatement->resultColName[i],
                     "USER_DISTIN_NAME", columnLength[i] );
        }

        /* convert the column name to lower case to match postgres */
        cptr = ( char* )myStatement->resultColName[i];
        for ( j = 0; j < columnLength[i]; j++ ) {
            if ( *cptr == '\0' ) {
                break;
            }
            if ( *cptr == ':' ) {
                break;
            }
            if ( *cptr >= 'A' && *cptr <= 'Z' ) {
                *cptr += ( ( int )'a' - ( int )'A' );
            }
            cptr++;
        }

        myStatement->resultValue[i] = ( char * )malloc( ( int )columnLength[i] + 2 );
        strcpy( ( char * )myStatement->resultValue[i], "" );

        stat = OCIDefineByPos( p_statement, &p_dfn, p_err, counter,
                               ( dvoid * ) myStatement->resultValue[i],
                               ( sword ) columnLength[i], SQLT_STR,
                               ( dvoid * )&indicator[i],
                               ( ub2 * )0, ( ub2 * )0, OCI_DEFAULT );
        if ( stat != OCI_SUCCESS ) {
            rodsLog( LOG_ERROR, "cllExecSqlWithResult: OCIDefineByPos failed: %d", stat );
            logOraError( LOG_ERROR, p_err, stat );
            return CAT_OCI_ERROR;
        }


        /* increment counter and get next descriptor, if there is one */
        counter++;
        stat = OCIParamGet( ( dvoid * )p_statement, OCI_HTYPE_STMT, p_err,
                            ( dvoid ** )&mypard, ( ub4 ) counter );
    }


    if ( counter == 1 ) {
        rodsLog( LOG_ERROR, "cllExecSqlWithResult: SQLNumResultCols failed: %d",
                 stat );
        return -2;
    }
    myStatement->numOfCols = counter - 1;

    return 0;
}