mirror of https://github.com/sipwise/kamailio.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
962 lines
22 KiB
962 lines
22 KiB
/*
|
|
* DBText module core functions
|
|
*
|
|
* Copyright (C) 2001-2003 FhG Fokus
|
|
*
|
|
* This file is part of Kamailio, a free SIP server.
|
|
*
|
|
* Kamailio is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version
|
|
*
|
|
* Kamailio is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <stdlib.h>
|
|
#include <setjmp.h>
|
|
|
|
#include "../../core/mem/mem.h"
|
|
|
|
#include "dbt_res.h"
|
|
|
|
#define SIGN(_i) ((_i) > 0 ? 1 : ((_i) < 0 ? -1 : 0))
|
|
|
|
dbt_result_p dbt_result_new(dbt_table_p _dtp, int *_lres, int _sz)
|
|
{
|
|
dbt_result_p _dres = NULL;
|
|
int i, n;
|
|
char *p;
|
|
|
|
if(!_dtp || _sz < 0)
|
|
return NULL;
|
|
|
|
if(!_lres)
|
|
_sz = _dtp->nrcols;
|
|
|
|
_dres = (dbt_result_p)pkg_malloc(sizeof(dbt_result_t));
|
|
if(!_dres)
|
|
return NULL;
|
|
_dres->colv = (dbt_column_p)pkg_malloc(_sz * sizeof(dbt_column_t));
|
|
if(!_dres->colv) {
|
|
LM_DBG("no pkg memory!\n");
|
|
pkg_free(_dres);
|
|
return NULL;
|
|
}
|
|
memset(_dres->colv, 0, _sz * sizeof(dbt_column_t));
|
|
LM_DBG("new res with %d cols\n", _sz);
|
|
for(i = 0; i < _sz; i++) {
|
|
n = (_lres) ? _dtp->colv[_lres[i]]->name.len : _dtp->colv[i]->name.len;
|
|
p = (_lres) ? _dtp->colv[_lres[i]]->name.s : _dtp->colv[i]->name.s;
|
|
_dres->colv[i].name.s = (char *)pkg_malloc((n + 1) * sizeof(char));
|
|
if(!_dres->colv[i].name.s) {
|
|
LM_DBG("no pkg memory\n");
|
|
goto clean;
|
|
}
|
|
_dres->colv[i].name.len = n;
|
|
strncpy(_dres->colv[i].name.s, p, n);
|
|
_dres->colv[i].name.s[n] = 0;
|
|
_dres->colv[i].type =
|
|
(_lres) ? _dtp->colv[_lres[i]]->type : _dtp->colv[i]->type;
|
|
}
|
|
|
|
_dres->nrcols = _sz;
|
|
_dres->nrrows = 0;
|
|
_dres->rows = NULL;
|
|
|
|
return _dres;
|
|
clean:
|
|
while(i >= 0) {
|
|
if(_dres->colv[i].name.s)
|
|
pkg_free(_dres->colv[i].name.s);
|
|
i--;
|
|
}
|
|
pkg_free(_dres->colv);
|
|
pkg_free(_dres);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int _dbt_result_free(dbt_result_p _dres)
|
|
{
|
|
dbt_row_p _rp = NULL, _rp0 = NULL;
|
|
int i;
|
|
|
|
if(!_dres)
|
|
return -1;
|
|
_rp = _dres->rows;
|
|
while(_rp) {
|
|
_rp0 = _rp;
|
|
_rp = _rp->next;
|
|
if(_rp0->fields) {
|
|
for(i = 0; i < _dres->nrcols; i++) {
|
|
if((_dres->colv[i].type == DB1_STR
|
|
|| _dres->colv[i].type == DB1_STRING
|
|
|| _dres->colv[i].type == DB1_BLOB)
|
|
&& _rp0->fields[i].val.str_val.s)
|
|
pkg_free(_rp0->fields[i].val.str_val.s);
|
|
}
|
|
pkg_free(_rp0->fields);
|
|
}
|
|
pkg_free(_rp0);
|
|
}
|
|
if(_dres->colv) {
|
|
for(i = 0; i < _dres->nrcols; i++) {
|
|
if(_dres->colv[i].name.s)
|
|
pkg_free(_dres->colv[i].name.s);
|
|
}
|
|
pkg_free(_dres->colv);
|
|
}
|
|
|
|
pkg_free(_dres);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dbt_result_free(db1_con_t *_h, dbt_table_p _dres)
|
|
{
|
|
if((!_h)) {
|
|
LM_ERR("invalid parameter value\n");
|
|
return -1;
|
|
}
|
|
|
|
if(!_dres)
|
|
return 0;
|
|
|
|
dbt_db_del_table(DBT_CON_CONNECTION(_h), &_dres->name, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dbt_result_add_row(dbt_result_p _dres, dbt_row_p _drp)
|
|
{
|
|
if(!_dres || !_drp)
|
|
return -1;
|
|
_dres->nrrows++;
|
|
|
|
if(_dres->rows)
|
|
(_dres->rows)->prev = _drp;
|
|
_drp->next = _dres->rows;
|
|
_dres->rows = _drp;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int *dbt_get_refs(dbt_table_p _dtp, db_key_t *_k, int _n)
|
|
{
|
|
int i, j, *_lref = NULL;
|
|
|
|
if(!_dtp || !_k || _n < 0)
|
|
return NULL;
|
|
|
|
_lref = (int *)pkg_malloc(_n * sizeof(int));
|
|
if(!_lref)
|
|
return NULL;
|
|
|
|
for(i = 0; i < _n; i++) {
|
|
for(j = 0; j < _dtp->nrcols; j++) {
|
|
if(_k[i]->len == _dtp->colv[j]->name.len
|
|
&& !strncasecmp(_k[i]->s, _dtp->colv[j]->name.s,
|
|
_dtp->colv[j]->name.len)) {
|
|
_lref[i] = j;
|
|
break;
|
|
}
|
|
}
|
|
if(j >= _dtp->nrcols) {
|
|
LM_ERR("column <%.*s> not found\n", _k[i]->len, _k[i]->s);
|
|
pkg_free(_lref);
|
|
return NULL;
|
|
}
|
|
}
|
|
return _lref;
|
|
}
|
|
|
|
|
|
int dbt_row_match(dbt_table_p _dtp, dbt_row_p _drp, int *_lkey, db_op_t *_op,
|
|
db_val_t *_v, int _n)
|
|
{
|
|
int i, res;
|
|
if(!_dtp || !_drp)
|
|
return 0;
|
|
if(!_lkey)
|
|
return 1;
|
|
for(i = 0; i < _n; i++) {
|
|
res = dbt_cmp_val(&_drp->fields[_lkey[i]], &_v[i]);
|
|
if(!_op || !strcmp(_op[i], OP_EQ)) {
|
|
if(res != 0)
|
|
return 0;
|
|
} else {
|
|
if(!strcmp(_op[i], OP_NEQ)) {
|
|
if(res == 0)
|
|
return 0;
|
|
} else {
|
|
if(!strcmp(_op[i], OP_LT)) {
|
|
if(res != -1)
|
|
return 0;
|
|
} else {
|
|
if(!strcmp(_op[i], OP_GT)) {
|
|
if(res != 1)
|
|
return 0;
|
|
} else {
|
|
if(!strcmp(_op[i], OP_LEQ)) {
|
|
if(res == 1)
|
|
return 0;
|
|
} else {
|
|
if(!strcmp(_op[i], OP_GEQ)) {
|
|
if(res == -1)
|
|
return 0;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int dbt_result_extract_fields(
|
|
dbt_table_p _dtp, dbt_row_p _drp, int *_lres, dbt_result_p _dres)
|
|
{
|
|
dbt_row_p _rp = NULL;
|
|
int i, n;
|
|
|
|
if(!_dtp || !_drp || !_dres || _dres->nrcols <= 0)
|
|
return -1;
|
|
|
|
_rp = dbt_result_new_row(_dres);
|
|
if(!_rp)
|
|
return -1;
|
|
|
|
for(i = 0; i < _dres->nrcols; i++) {
|
|
n = (_lres) ? _lres[i] : i;
|
|
if(dbt_is_neq_type(_dres->colv[i].type, _dtp->colv[n]->type)) {
|
|
LM_DBG("wrong types!\n");
|
|
goto clean;
|
|
}
|
|
_rp->fields[i].nul = _drp->fields[n].nul;
|
|
if(_rp->fields[i].nul) {
|
|
memset(&(_rp->fields[i].val), 0, sizeof(_rp->fields[i].val));
|
|
continue;
|
|
}
|
|
|
|
switch(_dres->colv[i].type) {
|
|
case DB1_INT:
|
|
case DB1_DATETIME:
|
|
case DB1_BITMAP:
|
|
_rp->fields[i].type = _dres->colv[i].type;
|
|
_rp->fields[i].val.int_val = _drp->fields[n].val.int_val;
|
|
break;
|
|
case DB1_DOUBLE:
|
|
_rp->fields[i].type = DB1_DOUBLE;
|
|
_rp->fields[i].val.double_val = _drp->fields[n].val.double_val;
|
|
break;
|
|
case DB1_STRING:
|
|
case DB1_STR:
|
|
case DB1_BLOB:
|
|
_rp->fields[i].type = _dres->colv[i].type;
|
|
_rp->fields[i].val.str_val.len =
|
|
_drp->fields[n].val.str_val.len;
|
|
_rp->fields[i].val.str_val.s = (char *)pkg_malloc(
|
|
sizeof(char) * (_drp->fields[n].val.str_val.len + 1));
|
|
if(!_rp->fields[i].val.str_val.s)
|
|
goto clean;
|
|
memcpy(_rp->fields[i].val.str_val.s,
|
|
_drp->fields[n].val.str_val.s,
|
|
_rp->fields[i].val.str_val.len);
|
|
_rp->fields[i].val.str_val.s[_rp->fields[i].val.str_val.len] =
|
|
0;
|
|
break;
|
|
default:
|
|
goto clean;
|
|
}
|
|
}
|
|
|
|
if(_dres->rows)
|
|
(_dres->rows)->prev = _rp;
|
|
_rp->next = _dres->rows;
|
|
_dres->rows = _rp;
|
|
_dres->nrrows++;
|
|
|
|
return 0;
|
|
|
|
clean:
|
|
LM_DBG("make clean!\n");
|
|
while(i >= 0) {
|
|
if((_rp->fields[i].type == DB1_STRING || _rp->fields[i].type == DB1_STR
|
|
|| _rp->fields[i].type == DB1_BLOB)
|
|
&& !_rp->fields[i].nul && _rp->fields[i].val.str_val.s)
|
|
pkg_free(_rp->fields[i].val.str_val.s);
|
|
|
|
i--;
|
|
}
|
|
pkg_free(_rp->fields);
|
|
pkg_free(_rp);
|
|
|
|
return -1;
|
|
}
|
|
|
|
int dbt_result_print(dbt_table_p _dres)
|
|
{
|
|
int i;
|
|
FILE *fout = stderr;
|
|
dbt_row_p rowp = NULL;
|
|
char *p;
|
|
|
|
if(!_dres || _dres->nrcols <= 0) {
|
|
LM_INFO("NO PRINT\n");
|
|
return -1;
|
|
}
|
|
|
|
fprintf(fout, "\nContent of result\n");
|
|
|
|
for(i = 0; i < _dres->nrcols; i++) {
|
|
switch(_dres->colv[i]->type) {
|
|
case DB1_INT:
|
|
fprintf(fout, "%.*s(int", _dres->colv[i]->name.len,
|
|
_dres->colv[i]->name.s);
|
|
if(_dres->colv[i]->flag & DBT_FLAG_NULL)
|
|
fprintf(fout, ",null");
|
|
fprintf(fout, ") ");
|
|
break;
|
|
case DB1_DOUBLE:
|
|
fprintf(fout, "%.*s(double", _dres->colv[i]->name.len,
|
|
_dres->colv[i]->name.s);
|
|
if(_dres->colv[i]->flag & DBT_FLAG_NULL)
|
|
fprintf(fout, ",null");
|
|
fprintf(fout, ") ");
|
|
break;
|
|
case DB1_STR:
|
|
case DB1_STRING:
|
|
fprintf(fout, "%.*s(str", _dres->colv[i]->name.len,
|
|
_dres->colv[i]->name.s);
|
|
if(_dres->colv[i]->flag & DBT_FLAG_NULL)
|
|
fprintf(fout, ",null");
|
|
fprintf(fout, ") ");
|
|
break;
|
|
default:
|
|
LM_INFO("TYPE NOT HANDLED %i\n", _dres->colv[i]->type);
|
|
return -1;
|
|
}
|
|
}
|
|
fprintf(fout, "\n");
|
|
rowp = _dres->rows;
|
|
while(rowp) {
|
|
for(i = 0; i < _dres->nrcols; i++) {
|
|
switch(_dres->colv[i]->type) {
|
|
case DB1_INT:
|
|
if(rowp->fields[i].nul)
|
|
fprintf(fout, "N ");
|
|
else
|
|
fprintf(fout, "%d ", rowp->fields[i].val.int_val);
|
|
break;
|
|
case DB1_DOUBLE:
|
|
if(rowp->fields[i].nul)
|
|
fprintf(fout, "N ");
|
|
else
|
|
fprintf(fout, "%.2f ", rowp->fields[i].val.double_val);
|
|
break;
|
|
case DB1_STR:
|
|
case DB1_STRING:
|
|
fprintf(fout, "\"");
|
|
if(!rowp->fields[i].nul) {
|
|
p = rowp->fields[i].val.str_val.s;
|
|
while(p < rowp->fields[i].val.str_val.s
|
|
+ rowp->fields[i].val.str_val.len) {
|
|
switch(*p) {
|
|
case '\n':
|
|
fprintf(fout, "\\n");
|
|
break;
|
|
case '\r':
|
|
fprintf(fout, "\\r");
|
|
break;
|
|
case '\t':
|
|
fprintf(fout, "\\t");
|
|
break;
|
|
case '\\':
|
|
fprintf(fout, "\\\\");
|
|
break;
|
|
case '"':
|
|
fprintf(fout, "\\\"");
|
|
break;
|
|
case '\0':
|
|
fprintf(fout, "\\0");
|
|
break;
|
|
default:
|
|
fprintf(fout, "%c", *p);
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
fprintf(fout, "\" ");
|
|
break;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
fprintf(fout, "\n");
|
|
rowp = rowp->next;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int dbt_cmp_val(dbt_val_p _vp, db_val_t *_v)
|
|
{
|
|
int _l, _n;
|
|
if(!_vp && !_v)
|
|
return 0;
|
|
if(!_v)
|
|
return 1;
|
|
if(!_vp)
|
|
return -1;
|
|
if(_vp->nul && _v->nul)
|
|
return 0;
|
|
if(_v->nul)
|
|
return 1;
|
|
if(_vp->nul)
|
|
return -1;
|
|
|
|
switch(VAL_TYPE(_v)) {
|
|
case DB1_INT:
|
|
return (_vp->val.int_val < _v->val.int_val) ? -1
|
|
: (_vp->val.int_val > _v->val.int_val) ? 1
|
|
: 0;
|
|
|
|
case DB1_BIGINT:
|
|
LM_ERR("BIGINT not supported\n");
|
|
return -1;
|
|
|
|
case DB1_DOUBLE:
|
|
return (_vp->val.double_val < _v->val.double_val) ? -1
|
|
: (_vp->val.double_val > _v->val.double_val) ? 1
|
|
: 0;
|
|
case DB1_DATETIME:
|
|
return (_vp->val.int_val < _v->val.time_val) ? -1
|
|
: (_vp->val.int_val > _v->val.time_val) ? 1
|
|
: 0;
|
|
case DB1_STRING:
|
|
_l = strlen(_v->val.string_val);
|
|
_l = (_l > _vp->val.str_val.len) ? _vp->val.str_val.len : _l;
|
|
_n = strncasecmp(_vp->val.str_val.s, _v->val.string_val, _l);
|
|
if(_n)
|
|
return SIGN(_n);
|
|
if(_vp->val.str_val.len == strlen(_v->val.string_val))
|
|
return 0;
|
|
if(_l == _vp->val.str_val.len)
|
|
return -1;
|
|
return 1;
|
|
case DB1_STR:
|
|
_l = _v->val.str_val.len;
|
|
_l = (_l > _vp->val.str_val.len) ? _vp->val.str_val.len : _l;
|
|
_n = strncasecmp(_vp->val.str_val.s, _v->val.str_val.s, _l);
|
|
if(_n)
|
|
return SIGN(_n);
|
|
if(_vp->val.str_val.len == _v->val.str_val.len)
|
|
return 0;
|
|
if(_l == _vp->val.str_val.len)
|
|
return -1;
|
|
return 1;
|
|
case DB1_BLOB:
|
|
_l = _v->val.blob_val.len;
|
|
_l = (_l > _vp->val.str_val.len) ? _vp->val.str_val.len : _l;
|
|
_n = strncasecmp(_vp->val.str_val.s, _v->val.blob_val.s, _l);
|
|
if(_n)
|
|
return SIGN(_n);
|
|
if(_vp->val.str_val.len == _v->val.blob_val.len)
|
|
return 0;
|
|
if(_l == _vp->val.str_val.len)
|
|
return -1;
|
|
return 1;
|
|
case DB1_BITMAP:
|
|
return (_vp->val.int_val < _v->val.bitmap_val) ? -1
|
|
: (_vp->val.int_val > _v->val.bitmap_val) ? 1
|
|
: 0;
|
|
default:
|
|
LM_ERR("invalid datatype %d\n", VAL_TYPE(_v));
|
|
return -2;
|
|
}
|
|
return -2;
|
|
}
|
|
|
|
dbt_row_p dbt_result_new_row(dbt_result_p _dres)
|
|
{
|
|
dbt_row_p _drp = NULL;
|
|
if(!_dres || _dres->nrcols <= 0)
|
|
return NULL;
|
|
|
|
_drp = (dbt_row_p)pkg_malloc(sizeof(dbt_row_t));
|
|
if(!_drp)
|
|
return NULL;
|
|
memset(_drp, 0, sizeof(dbt_row_t));
|
|
_drp->fields = (dbt_val_p)pkg_malloc(_dres->nrcols * sizeof(dbt_val_t));
|
|
if(!_drp->fields) {
|
|
pkg_free(_drp);
|
|
return NULL;
|
|
}
|
|
memset(_drp->fields, 0, _dres->nrcols * sizeof(dbt_val_t));
|
|
|
|
_drp->next = _drp->prev = NULL;
|
|
|
|
return _drp;
|
|
}
|
|
|
|
//dbt_row_p dbt_result_new_rows(dbt_row_p* _res, int rows, int cols)
|
|
//{
|
|
// dbt_row_p _drp = NULL;
|
|
// if(!_dres || _dres->nrcols<=0)
|
|
// return NULL;
|
|
//
|
|
// _drp = (dbt_row_p)shm_malloc(sizeof(dbt_row_t) * rows);
|
|
// if(!_drp)
|
|
// return NULL;
|
|
// memset(_drp, 0, sizeof(dbt_row_t));
|
|
// _drp->fields = (dbt_val_p)shm_malloc(_dres->nrcols*sizeof(dbt_val_t));
|
|
// if(!_drp->fields)
|
|
// {
|
|
// shm_free(_drp);
|
|
// return NULL;
|
|
// }
|
|
// memset(_drp->fields, 0, _dres->nrcols*sizeof(dbt_val_t));
|
|
//
|
|
// _drp->next = _drp->prev = NULL;
|
|
//
|
|
// return _drp;
|
|
//}
|
|
|
|
|
|
/* The _o clause to query is not really a db_key_t, it is SQL (str).
|
|
* db_mysql and db_postgres simply paste it into SQL, we need to parse it. */
|
|
/* Format of _o: column1 [ASC|DESC], column2 [ASC|DESC], ... */
|
|
int dbt_parse_orderbyclause(
|
|
db_key_t **_o_k, char **_o_op, int *_o_n, db_key_t _o)
|
|
{
|
|
char *_po, *_ps, *_pe;
|
|
char _c = '\0';
|
|
char _d[8];
|
|
int _n;
|
|
int _i;
|
|
str *_s;
|
|
|
|
/* scan _o, count ',' -> upper bound for no of columns */
|
|
_n = 1;
|
|
for(_i = 0; _i < _o->len; _i++)
|
|
if(_o->s[_i] == ',')
|
|
_n++;
|
|
|
|
/* *_o_k will include the db_key_ts, the strs, a copy of _o and \0 */
|
|
*_o_k = pkg_malloc((sizeof(db_key_t) + sizeof(str)) * _n + _o->len + 1);
|
|
if(!*_o_k)
|
|
return -1;
|
|
_s = (str *)((char *)(*_o_k) + sizeof(db_key_t) * _n);
|
|
for(_i = 0; _i < _n; _i++)
|
|
(*_o_k)[_i] = &_s[_i];
|
|
_po = (char *)(*_o_k) + (sizeof(db_key_t) + sizeof(str)) * _n;
|
|
memcpy(_po, _o->s, _o->len);
|
|
*(_po + _o->len) = '\0';
|
|
|
|
*_o_op = pkg_malloc(sizeof(char) * _n);
|
|
if(!*_o_op) {
|
|
pkg_free(*_o_k);
|
|
return -1;
|
|
}
|
|
|
|
*_o_n = 0;
|
|
_ps = _po;
|
|
while(*_o_n < _n) {
|
|
while(*_ps == ' ')
|
|
_ps++;
|
|
if(*_ps == '\0')
|
|
break;
|
|
strcpy(_d, " \f\n\r\t\v,"); /* isspace() and comma */
|
|
if(*_ps == '"' || *_ps == '\'') /* detect quote */
|
|
{
|
|
_d[0] = *_ps;
|
|
_d[1] = '\0';
|
|
_ps++;
|
|
}
|
|
_pe = strpbrk(_ps, _d); /* search quote, space, comma or eos */
|
|
if(!_pe && _d[0] == ' ') /* if token is last token in string */
|
|
_pe = _po + _o->len; /* point to end of string */
|
|
if(!_pe) /* we were looking for quote but found none */
|
|
goto parse_error;
|
|
|
|
/* _ps points to start of column-name,
|
|
* _pe points after the column-name, on quote, space, comma, or '\0' */
|
|
_c = *_pe;
|
|
*_pe = '\0';
|
|
(*_o_k)[*_o_n]->s = _ps;
|
|
(*_o_k)[*_o_n]->len = _pe - _ps;
|
|
(*_o_op)[*_o_n] = '<'; /* default */
|
|
(*_o_n)++;
|
|
|
|
if(_c == '\0')
|
|
break;
|
|
|
|
/* go beyond current token */
|
|
_ps = _pe + 1;
|
|
if(_c == ',')
|
|
continue;
|
|
while(*_ps == ' ')
|
|
_ps++;
|
|
if(*_ps == ',') {
|
|
_ps++;
|
|
continue;
|
|
}
|
|
if(*_ps == '\0')
|
|
break;
|
|
|
|
/* there is ASC OR DESC qualifier */
|
|
if(strncasecmp(_ps, "DESC", 4) == 0) {
|
|
(*_o_op)[*_o_n - 1] = '>';
|
|
_ps += 4;
|
|
} else if(strncasecmp(_ps, "ASC", 3) == 0) {
|
|
_ps += 3;
|
|
} else
|
|
goto parse_error;
|
|
|
|
/* point behind qualifier */
|
|
while(*_ps == ' ')
|
|
_ps++;
|
|
if(*_ps == ',') {
|
|
_ps++;
|
|
continue;
|
|
}
|
|
if(*_ps == '\0')
|
|
break;
|
|
goto parse_error;
|
|
}
|
|
|
|
if(*_ps != '\0'
|
|
&& _c != '\0') /* that means more elements than _tbc->nrcols */
|
|
goto parse_error;
|
|
|
|
if(*_o_n == 0) /* there weren't actually any columns */
|
|
{
|
|
pkg_free(*_o_k);
|
|
pkg_free(*_o_op);
|
|
*_o_op = NULL;
|
|
*_o_k = NULL;
|
|
return 0; /* return success anyway */
|
|
}
|
|
|
|
return 0;
|
|
|
|
parse_error:
|
|
pkg_free(*_o_k);
|
|
pkg_free(*_o_op);
|
|
*_o_op = NULL;
|
|
*_o_k = NULL;
|
|
*_o_n = 0;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/* lres/_nc is the selected columns, _o_l/_o_n is the order-by columns:
|
|
* All order-by columns need to be extracted along with the selected columns,
|
|
* so any column in _o_l and not lres needs to be added to lres. _o_nc keeps
|
|
* track of the number of columns added to lres. */
|
|
int dbt_mangle_columnselection(
|
|
int **_lres, int *_nc, int *_o_nc, int *_o_l, int _o_n)
|
|
{
|
|
int _i, _j;
|
|
|
|
*_o_nc = 0;
|
|
|
|
if(!*_lres)
|
|
return 0; /* all columns selected, no need to worry */
|
|
|
|
/* count how many columns are affected */
|
|
for(_i = 0; _i < _o_n; _i++) /* loop over order-by columns */
|
|
{
|
|
for(_j = 0; _j < *_nc && (*_lres)[_j] != _o_l[_i]; _j++)
|
|
;
|
|
if(_j == *_nc) /* order-by column not found in select columns */
|
|
(*_o_nc)++;
|
|
}
|
|
|
|
if(*_o_nc == 0)
|
|
return 0; /* all order-by columns also selected, we're fine */
|
|
|
|
/* make _lres bigger */
|
|
*_lres = pkg_reallocxf(*_lres, sizeof(int) * (*_nc + *_o_nc));
|
|
if(!*_lres)
|
|
return -1;
|
|
|
|
/* add oder-by columns to select columns */
|
|
for(_i = 0; _i < _o_n; _i++) /* loop over order-by columns */
|
|
{
|
|
for(_j = 0; _j < *_nc && (*_lres)[_j] != _o_l[_i]; _j++)
|
|
;
|
|
if(_j == *_nc) /* order-by column not found in select columns */
|
|
{
|
|
(*_lres)[*_nc] = _o_l[_i];
|
|
(*_nc)++;
|
|
}
|
|
}
|
|
|
|
/* _lres, _nc modified, _o_nc returned */
|
|
return 0;
|
|
}
|
|
|
|
/* globals for qsort */
|
|
dbt_result_p dbt_sort_dres;
|
|
int *dbt_sort_o_l;
|
|
char *dbt_sort_o_op;
|
|
int dbt_sort_o_n;
|
|
jmp_buf dbt_sort_jmpenv;
|
|
|
|
|
|
/* comparison function for qsort */
|
|
int dbt_qsort_compar(const void *_a, const void *_b)
|
|
{
|
|
int _i, _j, _r;
|
|
|
|
for(_i = 0; _i < dbt_sort_o_n; _i++) {
|
|
_j = dbt_sort_o_l[_i];
|
|
_r = dbt_cmp_val(&(*(dbt_row_p *)_a)->fields[_j],
|
|
&(*(dbt_row_p *)_b)->fields[_j]);
|
|
if(_r == 0)
|
|
continue; /* no result yet, compare next column */
|
|
if(_r == +1 || _r == -1)
|
|
return (dbt_sort_o_op[_i] == '<') ? _r : -_r; /* ASC OR DESC */
|
|
/* error */
|
|
longjmp(dbt_sort_jmpenv, _r);
|
|
}
|
|
|
|
/* no result after comparing all columns, same */
|
|
return 0;
|
|
}
|
|
|
|
|
|
int dbt_sort_result(dbt_result_p _dres, int *_o_l, char *_o_op, int _o_n,
|
|
int *_lres, int _nc)
|
|
{
|
|
int _i, _j;
|
|
dbt_row_p *_a;
|
|
dbt_row_p _el;
|
|
|
|
/* first we need to rewrite _o_l in terms of _lres */
|
|
if(_lres) {
|
|
for(_i = 0; _i < _o_n; _i++) /* loop over order-by columns */
|
|
{
|
|
/* depends on correctness of dbt_mangle_columnselection */
|
|
for(_j = 0; _lres[_j] != _o_l[_i]; _j++ /*, assert(_j < _nc)*/)
|
|
;
|
|
_o_l[_i] = _j;
|
|
}
|
|
}
|
|
|
|
/* rewrite linked list to array */
|
|
_a = pkg_malloc(sizeof(dbt_row_p) * _dres->nrrows);
|
|
if(!_a)
|
|
return -1;
|
|
for(_el = _dres->rows, _i = 0; _el != NULL; _el = _el->next, _i++)
|
|
_a[_i] = _el;
|
|
|
|
/* set globals */
|
|
dbt_sort_dres = _dres;
|
|
dbt_sort_o_l = _o_l;
|
|
dbt_sort_o_op = _o_op;
|
|
dbt_sort_o_n = _o_n;
|
|
_i = setjmp(dbt_sort_jmpenv); /* exception handling */
|
|
if(_i) {
|
|
/* error occurred during qsort */
|
|
LM_ERR("qsort aborted\n");
|
|
pkg_free(_a);
|
|
return _i;
|
|
}
|
|
|
|
qsort(_a, _dres->nrrows, sizeof(dbt_row_p), &dbt_qsort_compar);
|
|
|
|
/* restore linked list */
|
|
for(_i = 0; _i < _dres->nrrows; _i++) {
|
|
_a[_i]->prev = (_i > 0) ? _a[_i - 1] : NULL;
|
|
_a[_i]->next = (_i + 1 < _dres->nrrows) ? _a[_i + 1] : NULL;
|
|
}
|
|
_dres->rows = _a[0];
|
|
|
|
pkg_free(_a);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Remove the columns that were added to the result to facilitate sorting.
|
|
* The additional columns constitute the end of the queue. Instead of
|
|
* actually removing them with realloc, they are simply kept around, but
|
|
* hidden. For string-columns, the allocated string is however freed. */
|
|
void dbt_project_result(dbt_result_p _dres, int _o_nc)
|
|
{
|
|
int _i;
|
|
dbt_row_p _drp;
|
|
|
|
if(!_o_nc)
|
|
return;
|
|
|
|
/* check whether there are string columns, free them */
|
|
for(_i = _dres->nrcols - _o_nc; _i < _dres->nrcols; _i++) {
|
|
if(_dres->colv[_i].type == DB1_STRING || _dres->colv[_i].type == DB1_STR
|
|
|| _dres->colv[_i].type == DB1_BLOB) {
|
|
for(_drp = _dres->rows; _drp != NULL; _drp = _drp->next) {
|
|
if(!_drp->fields[_i].nul
|
|
&& (_drp->fields[_i].type == DB1_STRING
|
|
|| _drp->fields[_i].type == DB1_STR
|
|
|| _drp->fields[_i].type == DB1_BLOB)) {
|
|
pkg_free(_drp->fields[_i].val.str_val.s);
|
|
_drp->fields[_i].val.str_val.s = NULL;
|
|
_drp->fields[_i].val.str_val.len = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* free the string containing the column name */
|
|
pkg_free(_dres->colv[_i].name.s);
|
|
_dres->colv[_i].name.s = NULL;
|
|
_dres->colv[_i].name.len = 0;
|
|
}
|
|
|
|
/* pretend the columns are gone, in dbt_free_query free will do the right thing */
|
|
_dres->nrcols -= _o_nc;
|
|
}
|
|
|
|
/* comparison function for qsort */
|
|
int dbt_qsort_compare_temp(const void *_a, const void *_b)
|
|
{
|
|
int _i, _j, _r;
|
|
|
|
for(_i = 0; _i < dbt_sort_o_n; _i++) {
|
|
_j = dbt_sort_o_l[_i];
|
|
_r = dbt_cmp_val(&(*(dbt_row_p *)_a)->fields[_j],
|
|
&(*(dbt_row_p *)_b)->fields[_j]);
|
|
if(_r == 0)
|
|
continue; /* no result yet, compare next column */
|
|
if(_r == +1 || _r == -1)
|
|
return (dbt_sort_o_op[_i] == '<') ? _r : -_r; /* ASC OR DESC */
|
|
/* error */
|
|
longjmp(dbt_sort_jmpenv, _r);
|
|
}
|
|
|
|
/* no result after comparing all columns, same */
|
|
return 0;
|
|
}
|
|
|
|
int dbt_sort_result_temp(
|
|
dbt_row_p *_res, int count, int *_o_l, char *_o_op, int _o_n)
|
|
{
|
|
int _i;
|
|
|
|
/* set globals */
|
|
dbt_sort_o_l = _o_l;
|
|
dbt_sort_o_op = _o_op;
|
|
dbt_sort_o_n = _o_n;
|
|
_i = setjmp(dbt_sort_jmpenv); /* exception handling */
|
|
if(_i) {
|
|
/* error occurred during qsort */
|
|
LM_ERR("qsort aborted\n");
|
|
return _i;
|
|
}
|
|
|
|
qsort(_res, count, sizeof(dbt_row_p), &dbt_qsort_compare_temp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
dbt_row_p dbt_result_extract_results(
|
|
dbt_table_p _dtp, dbt_row_p *pRows, int _nrows, int *_lres, int _ncols)
|
|
{
|
|
dbt_row_p pRow = NULL;
|
|
dbt_row_p pTopRow = NULL;
|
|
dbt_row_p pPrvRow = NULL;
|
|
int i, n, r;
|
|
|
|
if(!_dtp || !pRows || _ncols <= 0 || !_lres)
|
|
return NULL;
|
|
|
|
for(r = 0; r < _nrows; r++) {
|
|
pRow = dbt_row_new(_ncols);
|
|
|
|
for(i = 0; i < _ncols; i++) {
|
|
n = _lres[i];
|
|
pRow->fields[i].nul = pRows[r]->fields[n].nul;
|
|
if(pRow->fields[i].nul) {
|
|
memset(&(pRow->fields[i].val), 0, sizeof(pRow->fields[i].val));
|
|
continue;
|
|
}
|
|
|
|
switch(_dtp->colv[n]->type) {
|
|
case DB1_INT:
|
|
case DB1_DATETIME:
|
|
case DB1_BITMAP:
|
|
pRow->fields[i].type = _dtp->colv[n]->type;
|
|
pRow->fields[i].val.int_val =
|
|
pRows[r]->fields[n].val.int_val;
|
|
break;
|
|
case DB1_DOUBLE:
|
|
pRow->fields[i].type = DB1_DOUBLE;
|
|
pRow->fields[i].val.double_val =
|
|
pRows[r]->fields[n].val.double_val;
|
|
break;
|
|
case DB1_STRING:
|
|
case DB1_STR:
|
|
case DB1_BLOB:
|
|
pRow->fields[i].type = _dtp->colv[n]->type;
|
|
pRow->fields[i].val.str_val.len =
|
|
pRows[r]->fields[n].val.str_val.len;
|
|
pRow->fields[i].val.str_val.s = (char *)shm_malloc(
|
|
sizeof(char)
|
|
* (pRows[r]->fields[n].val.str_val.len + 1));
|
|
if(!pRow->fields[i].val.str_val.s)
|
|
goto clean;
|
|
memcpy(pRow->fields[i].val.str_val.s,
|
|
pRows[r]->fields[n].val.str_val.s,
|
|
pRows[r]->fields[n].val.str_val.len);
|
|
pRow->fields[i]
|
|
.val.str_val
|
|
.s[pRows[r]->fields[n].val.str_val.len] = 0;
|
|
break;
|
|
default:
|
|
goto clean;
|
|
}
|
|
}
|
|
|
|
if(pTopRow == NULL) {
|
|
pTopRow = pRow;
|
|
} else {
|
|
pRow->prev = pPrvRow;
|
|
pPrvRow->next = pRow;
|
|
}
|
|
pPrvRow = pRow;
|
|
}
|
|
|
|
return pTopRow;
|
|
|
|
clean:
|
|
LM_DBG("make clean!\n");
|
|
while(i >= 0) {
|
|
if((pRow->fields[i].type == DB1_STRING
|
|
|| pRow->fields[i].type == DB1_STR
|
|
|| pRow->fields[i].type == DB1_BLOB)
|
|
&& !pRow->fields[i].nul && pRow->fields[i].val.str_val.s)
|
|
shm_free(pRow->fields[i].val.str_val.s);
|
|
|
|
i--;
|
|
}
|
|
shm_free(pRow->fields);
|
|
shm_free(pRow);
|
|
|
|
return pTopRow;
|
|
}
|