kamailio/utils/db_oracle/getres.c

#include "orasel.h"
#include <math.h>
#include <assert.h>

/*
 * Uncomment next string if you will sell 'NULL' on unitialized NON text field
 */
//#define NULL_ID "NULL"

static char st_buf[65536];

enum type_t
{
	DB_STR = 0,
	DB_DATETIME,
	/* end of left alignment */
	DB_INT,
	DB_BITMAP,
	DB_DOUBLE /* MUST belast */
};

//---------------------------------------------------------
struct dmap
{
	OCIDefine **defh;
	union
	{
		dvoid *v;
		double *f;
		int *i;
		char *c;
		OCIDate *o;
	} * pv;
	dvoid **pval;
	ub2 *ilen;
	sb2 *ind;
	ub2 *len;
};
typedef struct dmap dmap_t;

//-----------------------------------------------------------------------------
static void dmap_init(dmap_t *_d, unsigned n)
{
	size_t sz = sizeof(*_d->defh) + sizeof(*_d->pv) + sizeof(*_d->pval)
				+ sizeof(*_d->ilen) + sizeof(*_d->ind) + sizeof(*_d->len);
	unsigned char *p = safe_malloc(sz * n);

	_d->defh = (void *)p;
	p += n * sizeof(*_d->defh);
	_d->pv = (void *)p;
	p += n * sizeof(*_d->pv);
	_d->pval = (void *)p;
	p += n * sizeof(*_d->pval);
	_d->ilen = (void *)p;
	p += n * sizeof(*_d->ilen);
	_d->ind = (void *)p;
	p += n * sizeof(*_d->ind);
	_d->len = (void *)p;
	//	p += n*sizeof(*_d->len);
}

//-----------------------------------------------------------------------------
/*
 * Get and convert columns from a result. Define handlers and buffers
 */
static void get_columns(const con_t *con, res_t *_r, dmap_t *_d)
{
	OCIParam *param;
	size_t tsz;
	ub4 i, n;
	sword status;

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

	if(status != OCI_SUCCESS)
		oraxit(status, con);

	if(!n)
		donegood("Empty table");

	dmap_init(_d, n);

	_r->names = (Str **)safe_malloc(n * sizeof(Str *));
	_r->types = (unsigned char *)safe_malloc(n * sizeof(unsigned char));
	_r->col_n = n;

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

		status = OCIParamGet(con->stmthp, 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;
			_r->names[i] = str_alloc((char *)name, len);
		}

		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:
			set_bitmap:
				ctype = DB_BITMAP;
				len = sizeof(unsigned);
				break;

			case SQLT_INT:
			set_int:
				ctype = DB_INT;
				len = sizeof(int);
				break;

			case SQLT_VNU:
			case SQLT_NUM:
				len = 0; /* PRECISION is ub1 (byte) */
				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;
					}
					if(sc < 0)
						sc = 0;
					ctype += sc;
				}
			case SQLT_FLT:
			case SQLT_BFLOAT:
			case SQLT_BDOUBLE:
			case SQLT_IBFLOAT:
			case SQLT_IBDOUBLE:
			case SQLT_PDN:
				len = sizeof(double);
				dtype = SQLT_FLT;
				break;

			case SQLT_DATE:
			case SQLT_DAT:
			case SQLT_ODT:
			case SQLT_TIMESTAMP:
			case SQLT_TIMESTAMP_TZ:
			case SQLT_TIMESTAMP_LTZ:
				ctype = DB_DATETIME;
				len = sizeof(OCIDate);
				dtype = SQLT_ODT;
				break;

			case SQLT_CLOB:
			case SQLT_BLOB:
			case SQLT_CHR:
			case SQLT_STR:
			case SQLT_VST:
			case SQLT_VCS:
			case SQLT_AFC:
			case SQLT_AVC:
				ctype = DB_STR;
				dtype = SQLT_CHR;
				len = 0; /* DATA_SIZE is ub2 (word) */
				status = OCIAttrGet(param, OCI_DTYPE_PARAM,
						(dvoid **)(dvoid *)&len, NULL, OCI_ATTR_DATA_SIZE,
						con->errhp);
				if(status != OCI_SUCCESS)
					goto ora_err;
				++len;
				break;

			default:
				errxit("unsupported datatype");
		}
		_r->types[i] = ctype;
		_d->ilen[i] = (ub2)len;
		_d->pv[i].v = st_buf + tsz;
		tsz += len;
		status = OCIDefineByPos(con->stmthp, &_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(tsz > sizeof(st_buf))
		errxit("too large row");
	return;

ora_err:
	oraxit(status, con);
}

//-----------------------------------------------------------------------------
/*
 * Convert data fron db format to internal format
 */
static void convert_row(const res_t *_res, Str ***_r, const dmap_t *_d)
{
	unsigned i, n = _res->col_n;
	Str **v;

	*_r = v = (Str **)safe_malloc(n * sizeof(Str **));

	for(i = 0; i < n; i++, v++) {
		char buf[64];
		unsigned char t = _res->types[i];

		if(_d->ind[i] == -1) {
			static const struct
			{
				unsigned len;
				char s[1];
			} _empty = {0, ""};
#ifdef NULL_ID
			static const struct
			{
				unsigned len;
				char s[sizeof(NULL_ID)];
			} _null = {sizeof(NULL_ID) - 1, NULL_ID};

			*v = (Str *)&_null;
			if(t != DB_STR)
				continue;
#endif
			*v = (Str *)&_empty;
			continue;
		}

		//		if (_d->ind[i]) errxit("truncated value in DB");

		switch(t) {
			case DB_STR:
				*v = str_alloc(_d->pv[i].c, _d->len[i]);
				break;

			case DB_INT:
				*v = str_alloc(
						buf, snprintf(buf, sizeof(buf), "%i", *_d->pv[i].i));
				break;

			case DB_BITMAP:
				*v = str_alloc(
						buf, snprintf(buf, sizeof(buf), "0x%X", *_d->pv[i].i));
				break;

			case DB_DATETIME: {
				struct tm tm;
				memset(&tm, 0, sizeof(tm));
				OCIDateGetTime(
						_d->pv[i].o, &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
				OCIDateGetDate(
						_d->pv[i].o, &tm.tm_year, &tm.tm_mon, &tm.tm_mday);
				if(tm.tm_mon)
					--tm.tm_mon;
				if(tm.tm_year >= 1900)
					tm.tm_year -= 1900;
				*v = str_alloc(
						buf, strftime(buf, sizeof(buf), "%d-%b-%Y %T", &tm));
			} break;

			case DB_DOUBLE:
				*v = str_alloc(
						buf, snprintf(buf, sizeof(buf), "%g", *_d->pv[i].f));
				break;

			default: {
				double x = fabs(*_d->pv[i].f);
				const char *fmt = "%.*f";
				if(x && (x >= 1.0e6 || x < 1.0e-5))
					fmt = "%.*e";
				*v = str_alloc(buf, snprintf(buf, sizeof(buf), fmt,
											(t - DB_DOUBLE), *_d->pv[i].f));
			} break;
		}
	}
}

//-----------------------------------------------------------------------------
/*
 * Get rows and convert it from oracle to db API representation
 */
static void get_rows(const con_t *con, res_t *_r, dmap_t *_d)
{
	ub4 rcnt;
	sword status;
	unsigned n = _r->col_n;

	memcpy(_d->len, _d->ilen, sizeof(_d->len[0]) * n);

	status = OCIStmtFetch2(
			con->stmthp, con->errhp, 1, OCI_FETCH_LAST, 0, OCI_DEFAULT);
	if(status != OCI_SUCCESS) {
		if(status == OCI_NO_DATA)
			donegood("Empty set");
		goto ora_err;
	}

	status = OCIAttrGet(con->stmthp, OCI_HTYPE_STMT, &rcnt, NULL,
			OCI_ATTR_CURRENT_POSITION, con->errhp);
	if(status != OCI_SUCCESS)
		goto ora_err;
	if(!rcnt)
		errxit("lastpos==0");

	_r->row_n = rcnt;
	_r->rows = (Str ***)safe_malloc(rcnt * sizeof(Str **));
	while(1) {
		convert_row(_r, &_r->rows[--rcnt], _d);
		if(!rcnt)
			return;

		memcpy(_d->len, _d->ilen, sizeof(_d->len[0]) * n);
		status = OCIStmtFetch2(
				con->stmthp, con->errhp, 1, OCI_FETCH_PRIOR, 0, OCI_DEFAULT);
		if(status != OCI_SUCCESS)
			break;
	}
ora_err:
	oraxit(status, con);
}

//-----------------------------------------------------------------------------
/*
 * Read database answer and fill the structure
 */
void get_res(const con_t *con, res_t *_r)
{
	dmap_t dmap;
	unsigned n;
	unsigned char *pt;

	get_columns(con, _r, &dmap);
	get_rows(con, _r, &dmap);
	n = _r->col_n;
	pt = _r->types;
	do {
		--n;
		assert(DB_STR == 0 && DB_DATETIME == 1);
		pt[n] = (pt[n] <= DB_DATETIME);
	} while(n);
}

//-----------------------------------------------------------------------------