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.
995 lines
22 KiB
995 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 "../../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_realloc(*_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 occured 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 occured 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)
|
|
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;
|
|
}
|