dbt_tb.c

Go to the documentation of this file.

/*
 * $Id: dbt_tb.c 4518 2008-07-28 15:39:28Z henningw $
 *
 * DBText library
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * History:
 * --------
 * 2003-02-03 created by Daniel
 * 
 */

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>

#include "../../mem/shm_mem.h"
#include "../../mem/mem.h"
#include "../../dprint.h"
#include "../../locking.h"

#include "dbt_util.h"
#include "dbt_lib.h"


/**
 *
 */
dbt_column_p dbt_column_new(char *_s, int _l)
{
   dbt_column_p dcp = NULL;
   if(!_s || _l <=0)
      return NULL;
   dcp = (dbt_column_p)shm_malloc(sizeof(dbt_column_t));
   if(!dcp)
      return NULL;
   dcp->name.s  = (char*)shm_malloc((_l+1)*sizeof(char));
   if(!dcp->name.s)
   {
      shm_free(dcp);
      return NULL;
   }
   dcp->name.len = _l;
   strncpy(dcp->name.s, _s, _l);
   dcp->name.s[_l] = '\0';
   dcp->next = dcp->prev = NULL;
   dcp->type = 0;
   dcp->flag = DBT_FLAG_UNSET;

   return dcp;
}

/**
 *
 */
int dbt_column_free(dbt_column_p dcp)
{
   
   if(!dcp)
      return -1;
   if(dcp->name.s)
      shm_free(dcp->name.s);
   shm_free(dcp);
 
   return 0;
}

/**
 *
 */
dbt_row_p dbt_row_new(int _nf)
{
   int i;
   dbt_row_p _drp = NULL;

   _drp = (dbt_row_p)shm_malloc(sizeof(dbt_row_t));
   if(!_drp)
      return NULL;
   
   _drp->fields = (dbt_val_p)shm_malloc(_nf*sizeof(dbt_val_t));
   if(!_drp->fields)
   {
      shm_free(_drp);
      return NULL;
   }
   memset(_drp->fields, 0, _nf*sizeof(dbt_val_t));
   for(i=0; i<_nf; i++)
      _drp->fields[i].nul = 1;

   _drp->next = _drp->prev = NULL;

   return _drp;
}

/**
 *
 */
int dbt_row_free(dbt_table_p _dtp, dbt_row_p _drp)
{
   int i;
   
   if(!_dtp || !_drp)
      return -1;
   
   if(_drp->fields)
   {
      for(i=0; i<_dtp->nrcols; i++)
         if((_dtp->colv[i]->type==DB_STR || _dtp->colv[i]->type==DB_STRING
                  || _dtp->colv[i]->type==DB_BLOB)
               && _drp->fields[i].val.str_val.s)
            shm_free(_drp->fields[i].val.str_val.s);
      shm_free(_drp->fields);
   }
   shm_free(_drp);

   return 0;
}

/**
 *
 */
dbt_table_p dbt_table_new(const str *_tbname, const str *_dbname, const char *path)
{
   struct stat s;
   dbt_table_p dtp = NULL;
   if(!_tbname || !_dbname || !path)
      return NULL;
   
   dtp = (dbt_table_p)shm_malloc(sizeof(dbt_table_t));
   if(!dtp)
      goto done;
   dtp->name.s = (char*)shm_malloc((_tbname->len+1)*sizeof(char));
   if(!dtp->name.s)
   {
      shm_free(dtp);
      dtp = NULL;
      goto done;
   }
   memcpy(dtp->name.s, _tbname->s, _tbname->len);
   dtp->name.s[_tbname->len] = '\0';
   dtp->name.len = _tbname->len;
   
   dtp->dbname.s = (char*)shm_malloc((_dbname->len+1)*sizeof(char));
   if(!dtp->dbname.s)
   {
      shm_free(dtp->name.s);
      shm_free(dtp);
      dtp = NULL;
      goto done;
   }
   memcpy(dtp->dbname.s, _dbname->s, _dbname->len);
   dtp->dbname.s[_dbname->len] = '\0';
   dtp->dbname.len = _dbname->len;

   dtp->rows = NULL;
   dtp->cols = NULL;
   dtp->colv = NULL;
   dtp->mark = (int)time(NULL);
   dtp->flag = DBT_TBFL_ZERO;
   dtp->nrrows = dtp->nrcols = dtp->auto_val = 0;
   dtp->auto_col = -1;
   dtp->mt = 0;
   if(stat(path, &s) == 0)
   {
      dtp->mt = s.st_mtime;
      LM_DBG("mtime is %d\n", (int)s.st_mtime);
   }
   
done:
   return dtp;
}

/**
 *
 */
int dbt_table_free_rows(dbt_table_p _dtp)
{
   dbt_row_p _rp=NULL, _rp0=NULL;
   
   if(!_dtp || !_dtp->rows || !_dtp->colv)
      return -1;
   _rp = _dtp->rows;
   while(_rp)
   {
      _rp0=_rp;
      _rp=_rp->next;
      dbt_row_free(_dtp, _rp0);
   }
   
   dbt_table_update_flags(_dtp, DBT_TBFL_MODI, DBT_FL_SET, 1);
   
   _dtp->rows = NULL;
   _dtp->nrrows = 0;

   return 0;
}

/**
 *
 */
int dbt_table_add_row(dbt_table_p _dtp, dbt_row_p _drp)
{
   if(!_dtp || !_drp)
      return -1;
   
   if(dbt_table_check_row(_dtp, _drp))
      return -1;
   
   dbt_table_update_flags(_dtp, DBT_TBFL_MODI, DBT_FL_SET, 1);
   
   if(_dtp->rows)
      (_dtp->rows)->prev = _drp;
   _drp->next = _dtp->rows;
   _dtp->rows = _drp;
   _dtp->nrrows++;

   return 0;
}

/**
 *
 */
int dbt_table_free(dbt_table_p _dtp)
{
   dbt_column_p _cp=NULL, _cp0=NULL;
   
   if(!_dtp)
      return -1;

   if(_dtp->name.s)
      shm_free(_dtp->name.s);
   if(_dtp->dbname.s)
      shm_free(_dtp->dbname.s);
   
   if(_dtp->rows && _dtp->nrrows>0)
      dbt_table_free_rows(_dtp);
   
   _cp = _dtp->cols;
   while(_cp)
   {
      _cp0=_cp;
      _cp=_cp->next;
      dbt_column_free(_cp0);
   }
   if(_dtp->colv)
      shm_free(_dtp->colv);

   shm_free(_dtp);

   return 0;
}

/**
 *
 */
int dbt_row_set_val(dbt_row_p _drp, dbt_val_p _vp, int _t, int _idx)
{
   if(!_drp || !_vp || _idx<0)
      return -1;
   
   _drp->fields[_idx].nul = _vp->nul;
   _drp->fields[_idx].type = _t;

   if(!_vp->nul)
   {
      switch(_t)
      {
         case DB_STR:
         case DB_BLOB:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.str_val.s = 
               (char*)shm_malloc((_vp->val.str_val.len+1)*sizeof(char));
            if(!_drp->fields[_idx].val.str_val.s)
            {
               _drp->fields[_idx].nul = 1;
               return -1;
            }
            memcpy(_drp->fields[_idx].val.str_val.s, _vp->val.str_val.s,
               _vp->val.str_val.len);
            _drp->fields[_idx].val.str_val.s[_vp->val.str_val.len] = '\0';
            _drp->fields[_idx].val.str_val.len = _vp->val.str_val.len;
         break;
         
         case DB_STRING:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.str_val.len=_vp->val.str_val.len;
            
            _drp->fields[_idx].val.str_val.s = 
               (char*)shm_malloc((_drp->fields[_idx].val.str_val.len+1)
                             *sizeof(char));
            if(!_drp->fields[_idx].val.str_val.s)
            {
               _drp->fields[_idx].nul = 1;
               return -1;
            }
            memcpy(_drp->fields[_idx].val.str_val.s, _vp->val.string_val,
               _drp->fields[_idx].val.str_val.len);
            _drp->fields[_idx].val.str_val.s[_drp->fields[_idx].val.str_val.len] = '\0';
         break;
         
         case DB_DOUBLE:
            _drp->fields[_idx].type = DB_DOUBLE;
            _drp->fields[_idx].val.double_val = _vp->val.double_val;
         break;
         
         case DB_INT:
            _drp->fields[_idx].type = DB_INT;
            _drp->fields[_idx].val.int_val = _vp->val.int_val;
         break;
         
         case DB_DATETIME:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.int_val = (int)_vp->val.time_val;
         break;
         
         case DB_BITMAP:
            _drp->fields[_idx].type = DB_INT;
            _drp->fields[_idx].val.int_val = (int)_vp->val.bitmap_val;
         break;
         
         default:
            _drp->fields[_idx].nul = 1;
            return -1;
      }
   }
   
   return 0;
}

/**
 *
 */
int dbt_row_update_val(dbt_row_p _drp, dbt_val_p _vp, int _t, int _idx)
{
   if(!_drp || !_vp || _idx<0)
      return -1;
   
   _drp->fields[_idx].nul = _vp->nul;
   _drp->fields[_idx].type = _t;
   
   if(!_vp->nul)
   {
      switch(_t)
      {
         case DB_BLOB:
         case DB_STR:
            _drp->fields[_idx].type = _t;
            // free if already exists
            if(_drp->fields[_idx].val.str_val.s)
               shm_free(_drp->fields[_idx].val.str_val.s);
         
            _drp->fields[_idx].val.str_val.s = 
               (char*)shm_malloc((_vp->val.str_val.len+1)*sizeof(char));
            if(!_drp->fields[_idx].val.str_val.s)
            {
               _drp->fields[_idx].nul = 1;
               return -1;
            }
            memcpy(_drp->fields[_idx].val.str_val.s, _vp->val.str_val.s,
               _vp->val.str_val.len);
            _drp->fields[_idx].val.str_val.s[_vp->val.str_val.len] = '\0';
            _drp->fields[_idx].val.str_val.len = _vp->val.str_val.len;
         break;
         
         case DB_STRING:
            /* free if already exists */
            if(_drp->fields[_idx].val.str_val.s)
               shm_free(_drp->fields[_idx].val.str_val.s);

            _drp->fields[_idx].type = _t;
            if(_vp->type==DB_STR)
               _drp->fields[_idx].val.str_val.len=_vp->val.str_val.len;
            else
               _drp->fields[_idx].val.str_val.len
                                 =strlen(_vp->val.string_val);
            
            _drp->fields[_idx].val.str_val.s = 
               (char*)shm_malloc((_drp->fields[_idx].val.str_val.len+1)
                             *sizeof(char));
            if(!_drp->fields[_idx].val.str_val.s)
            {
               _drp->fields[_idx].nul = 1;
               return -1;
            }
            memcpy(_drp->fields[_idx].val.str_val.s, _vp->val.string_val,
               _drp->fields[_idx].val.str_val.len);
            _drp->fields[_idx].val.str_val.s[_vp->val.str_val.len] = '\0';
         break;
         
         case DB_DOUBLE:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.double_val = _vp->val.double_val;
         break;
         
         case DB_INT:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.int_val = _vp->val.int_val;
         break;
         
         case DB_DATETIME:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.int_val = (int)_vp->val.time_val;
         break;
         
         case DB_BITMAP:
            _drp->fields[_idx].type = _t;
            _drp->fields[_idx].val.int_val = (int)_vp->val.bitmap_val;
         break;
         
         default:
            LM_ERR("unsupported type %d in update\n",_t);
            _drp->fields[_idx].nul = 1;
            return -1;
      }
   }
   
   return 0;
}

/**
 *
 */
int dbt_table_check_row(dbt_table_p _dtp, dbt_row_p _drp)
{
   int i;
   if(!_dtp || _dtp->nrcols <= 0 || !_drp)
      return -1;
   
   for(i=0; i<_dtp->nrcols; i++)
   {
      if(!_drp->fields[i].nul 
            && dbt_is_neq_type(_dtp->colv[i]->type, _drp->fields[i].type))
      {
         LM_DBG("incompatible types - field %d [%d/%d]\n",i,
               _dtp->colv[i]->type, _drp->fields[i].type);
         return -1;
      }
      if(_dtp->colv[i]->flag & DBT_FLAG_NULL)
         continue;
      
      if(!_drp->fields[i].nul)
         continue;

      if(_dtp->colv[i]->type==DB_INT
         && (_dtp->colv[i]->flag & DBT_FLAG_AUTO)
         && i==_dtp->auto_col)
      {
         _drp->fields[i].nul = 0;
         _drp->fields[i].val.int_val = ++_dtp->auto_val;
         continue;
      }

      LM_DBG("null value not allowed - field %d\n",i);
      return -1;
   }
   
   return 0;
}

/**
 *
 */
int dbt_table_update_flags(dbt_table_p _dtp, int _f, int _o, int _m)
{
   if(!_dtp)
      return -1;
   
   if(_o == DBT_FL_SET)
      _dtp->flag |= _f;
   else if(_o == DBT_FL_UNSET)
         _dtp->flag &= ~_f;
   
   if(_m)
      _dtp->mark = (int)time(NULL);
   
   return 0;
}