开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
catfun.c
资源名称：gnusql-0.7b5.1.tar.gz　[点击查看]
上传用户：dgyhgb
上传日期：2007-01-07
资源大小：676k
文件大小：39k
源码类别：

SQL Server

开发平台：

Unix_Linux

catfun.c：源码内容
  1. /*
  2.  *  catfun.c  -  DB catalogs request library
  3.  *               GNU SQL server
  4.  *
  5.  *  This file is a part of GNU SQL Server
  6.  *
  7.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  8.  *  Developed at the Institute of System Programming
  9.  *  This file is written by Konstantin Dyshlevoi.
  10.  *
  11.  *  This program is free software; you can redistribute it and/or modify
  12.  *  it under the terms of the GNU General Public License as published by
  13.  *  the Free Software Foundation; either version 2 of the License, or
  14.  *  (at your option) any later version.
  15.  *
  16.  *  This program is distributed in the hope that it will be useful,
  17.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  *  GNU General Public License for more details.
  20.  *
  21.  *  You should have received a copy of the GNU General Public License
  22.  *  along with this program; if not, write to the Free Software
  23.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24.  *
  25.  *  Contacts: gss@ispras.ru
  26.  *
  27.  */
  29. /* $Id: catfun.c,v 1.245 1997/03/31 03:46:38 kml Exp $ */
  31. #include "global.h"
  32. #include "type_lib.h"
  33. #include "inprtyp.h"
  34. #include "sql.h"
  35. #include "const.h"
  36. #include "engine/fieldtp.h"
  37. #include "engine/expop.h"
  38. #include "engine/pupsi.h"
  39. #include "index.h"
  40. #include "exti.h"
  41. #include "tree_gen.h"
  42. #include <assert.h>
  44. extern i4_t transaction;
  45. extern     DataUnit *data_st;
  46. extern i4_t dt_ind, dt_max;
  48. #define DU_ARR_LEN MAX_COLNO /* max of ..._COLNO */
  49. #define MAX_STAT_LEN 10      /* maximum string length for statistic */
  50. static DataUnit *du;
  51. static DataUnit *arg_du[DU_ARR_LEN];
  52. static DataUnit *res_du[DU_ARR_LEN];
  53. static i4_t num_rows[DU_ARR_LEN], ind_clm_nums[DU_ARR_LEN], tab_clm_nums[DU_ARR_LEN];
  55. /********************************************************************/
  57. #define CHECK_LEN(owner)  {if (strlen (owner) > MAX_USER_NAME_LNG) 
  58.                              owner[MAX_USER_NAME_LNG] = 0;}
  60. #define ARGDAT(num) (&((arg_du[num])->dat))
  61. #define RESDAT(num) (&((res_du[num])->dat))
  62. #define RESCOD(num) ((res_du[num])->type.code)
  64. #define IND_CLM_STR(num, adr)                          
  65. { (arg_du[num])->type.code = T_STR;                    
  66.   (arg_du[num])->type.len = strlen (adr);              
  67.   STR_PTR (ARGDAT(num)) = adr;                         
  68.   NL_FL   (ARGDAT(num)) = REGULAR_VALUE;               
  69. }
  71. #define TAB_CLM_STR(num, adr, colno)                   
  72. { IND_CLM_STR(num, adr);                               
  73.   tab_clm_nums[num] = colno;                           
  74. }
  76. #define IND_CLM_NUM(num, typ, adr)                     
  77. { (arg_du[num])->type.code = typ;                      
  78.   mem_to_DU (REGULAR_VALUE, typ, 0, adr, arg_du[num]); 
  79. }
  81. #define TAB_CLM_NUM(num, typ, adr, colno)              
  82. { IND_CLM_NUM(num, typ, adr);                          
  83.   tab_clm_nums[num] = colno;                           
  84. }
  86. #define RES_CLM(num, typ, colno)  
  87. {                                 
  88.   (res_du[num])->type.code = typ; 
  89.   num_rows[num] = colno;          
  90. }
  92. #define IND_READ(indid, an, rn)                           
  93.   ind_read (indid, an, arg_du, rn, num_rows, res_du, NULL, RSC)
  94. #define IND_NEXT_READ(indid, an, rn)                      
  95.   ind_read (indid, an, arg_du, rn, num_rows, res_du, &scanid, RSC)
  96. #define IND_DEL_READ(indid, an, rn)                      
  97.   ind_read (indid, an, arg_du, rn, num_rows, res_du, &scanid, DSC)
  98. #define IND_UPD_READ(indid, an, rn)                      
  99.   ind_read (indid, an, arg_du, rn, num_rows, res_du, &scanid, MSC)
  100. #define TAB_READ(tabid, an, nmax, rn) tab_read (tabid, an, nmax, tab_clm_nums,   
  101.                                                 arg_du, rn, num_rows, res_du)
  103. /* for strings "ptr" gets new address of the result string, *
  104.  * for number types the result is copied to "ptr"           */
  106. #define GET_RES_STR(num, ptr)               
  107. {                                           
  108.   if (NL_FL (RESDAT(num)) == REGULAR_VALUE) 
  109.     ptr = STR_PTR (RESDAT(num));            
  110.   else                                      
  111.     ptr = NULL;                             
  112. }
  114. #define GET_RES_NUM(num, ptr)                                
  115. { put_dat (&VL (RESDAT(num)), 0, RESCOD (num),               
  116.    REGULAR_VALUE, ptr, 0, RESCOD (num), NULL);       
  117. }
  119. void
  120. db_func_init (void)
  121. {
  122.   i4_t i;
  123.   
  124.   du = TYP_ALLOC (DU_ARR_LEN * 2, DataUnit);
  125.   for (i = 0; i < DU_ARR_LEN; i++)
  126.     {
  127.       arg_du[i] = du + i;
  128.       res_du[i] = du + i + DU_ARR_LEN;
  129.       ind_clm_nums[i] = i;
  130.     }
  131. } /* db_func_init */
  133. #define PUT_BUF(num, dat) {cond[num/2] |= (num/2 * 2 == num) ? dat : (char) dat << 4;}
  134. #define GET_BUF(num) (cond[num/2] & ((char) ((num/2 * 2 == num) ? 15 : 240)))
  136. int
  137. cond_form (i4_t clm_cnt, i4_t max_clm_num, i4_t *clm_nums,
  138.    DataUnit **cond_du, char **res_cond)
  139. /* forming of condition for open of scanning.                *
  140.    (max_clm_num = (max column number in array clm_nums) + 1) *
  141.  * Returns length of scale and pointer to it in res_cond     */
  142. {
  143.   i4_t i, err, sc_len, beg_len;
  144.   static i4_t cond_lng = 0;
  145.   static char *cond = NULL;
  146.   char *cur_in_cond;
  147.   
  148.   /* length of scale for condition */
  149.   beg_len = max_clm_num/2 + 1;
  150.   
  151.   /* length of condition */
  152.   for (sc_len = beg_len + clm_cnt * SZ_SHT, i = 0; i < clm_cnt; i++)
  153.     sc_len += sizeof_sqltype ((cond_du[i])->type);
  154.   
  155.   /* scale of condition making : */
  156.   CHECK_ARR_SIZE (cond, cond_lng, sc_len, char);
  157.   bzero (cond, sc_len);
  158.   for (i = 0; i < clm_cnt; i++)
  159.     PUT_BUF (clm_nums[i], EQ);
  160.   for (i = 0; i < max_clm_num; i++)
  161.     if (!GET_BUF (i))
  162.       PUT_BUF(i, ANY);
  163.   PUT_BUF (max_clm_num, ENDSC);
  164.   
  165.   /* the rest part of condition making : */
  166.   for (cur_in_cond = cond + beg_len, i = 0; i < clm_cnt; i++)
  167.     {
  168.       err = DU_to_buf (cond_du[i], &cur_in_cond, &((cond_du[i])->type));
  169.       if (err < 0)
  170. return err;
  171.     }
  172.   
  173.   *res_cond = cond;
  174.   return sc_len;
  175. } /* cond_form */
  177. int
  178. ind_read (Indid * indid, i4_t ind_clm_cnt, DataUnit **ind_cond_du, i4_t read_cnt,
  179.   i4_t *read_col_nums, DataUnit **read_du, Scanid *ext_scanid, char mode)
  180.      /* Reading read_cnt columns from table accordingly index indid and *
  181.       * given values (ind_cond_du) for finding in index;                *
  182.       * If ext_scanid == NULL => function tries to read only first row  *
  183.       *                        accordingly this index;                  *
  184.       * If ext_scanid != NULL  => function reads next row in ext_scanid *
  185.       * Function returns :  0 if the result was found,                  *
  186.       *                     <0 if the result of index scanning is empty */
  187. {
  188.   i4_t cod = 0, spn = 0, sc_len;
  189.   char *ind_cond;
  190.   Scanid local_scanid = -1, *scanid;
  191.   
  192.   scanid = (ext_scanid) ? ext_scanid : &local_scanid;
  193.   
  194.   if (*scanid < 0)
  195.     {
  196.       /* forming of condition for open of index scanning */
  197.       sc_len = cond_form (ind_clm_cnt, ind_clm_cnt, ind_clm_nums, ind_cond_du, &ind_cond);
  198.       if (sc_len < 0)
  199. return -ER_1;
  200.       
  201.       /* index scanning : */
  202.       cod = *scanid = openiscan (indid, &spn, mode, read_cnt, read_col_nums, 0,
  203.  NULL, sc_len, (cond_buf_t) ind_cond, 0, NULL);
  204.       if (spn > 0)
  205.         {
  206.           rollback (spn);
  207.           return -SYER;
  208.         }
  209.     }
  210.   
  211.   if (cod >= 0)
  212.     cod = findrow (*scanid, read_cnt, read_du);
  213.   if (!ext_scanid || cod < 0)
  214.     {
  215.       if (*scanid >= 0)
  216. closescan (*scanid);
  217.       *scanid = -1;
  218.     }
  219.   
  220.   return (cod);
  221. } /* ind_read */
  223. int
  224. tab_read (Tabid * tabid, i4_t tab_clm_cnt, i4_t max_clm_num,
  225.   i4_t *tab_col_nums, DataUnit **tab_cond_du,
  226.   i4_t read_cnt, i4_t *read_col_nums, DataUnit **read_du)
  227.      /* Reading read_cnt columns from table tabid accordingly   *
  228.       * given values (tab_cond_du) for finding in table;        *
  229.       * (max_clm_num = max column number in array tab_col_nums) *
  230.       * Function returns :  0 if the result was found,          *
  231.       *            <0 if the result of table scanning is empty  */
  232. {
  233.   i4_t cod = 0, spn = 0, sc_len,  def_num[1];
  234.   char *tab_cond;
  235.   Scanid scanid;
  236.   
  237.   def_num[0] = 0;
  238.   /* forming of condition for open of table scanning */
  239.   sc_len = cond_form (tab_clm_cnt, max_clm_num + 1, tab_col_nums, tab_cond_du, &tab_cond);
  240.   if (sc_len < 0)
  241.     return -ER_1;
  242.   
  243.   /* table scanning : */
  244.   if ((scanid = opentscan (tabid, &spn, 'R', (read_cnt) ? read_cnt : 1,
  245.    (read_cnt) ? read_col_nums : def_num,
  246.    sc_len, (cond_buf_t) tab_cond, 0, NULL)) < 0)
  247.     return (scanid);
  248.   if (spn > 0)
  249.     {
  250.       rollback (spn);
  251.       return -SYER;
  252.     }
  253.   cod = findrow (scanid, read_cnt, read_du);
  254.   closescan (scanid);
  255.   return (cod);
  256. } /* tab_read */
  258. int
  259. existsc (char *autnm)
  260.      /* checking the existing of scheme with name "autnm"
  261. the function result is no 0 if that scheme
  262. doesn't exist and 0 in another way
  263.      */
  265. {
  266.   CHECK_LEN (autnm);
  267.   
  268.   TAB_CLM_STR (0, autnm, SYSTABOWNER);
  270.   return TAB_READ (&systabtabid, 1, SYSTABOWNER, 0);
  271. } /* existsc */
  273. /*-------------------------------------------------*/
  274. int
  275. existtb (char *owner, char *tabnm, Tabid * tabid, char *type)
  276.      /* checking the existing in scheme the table with name
  277. tabnm; this name must be qualified (with authorization
  278. identifier); the result of function is 0
  279. if table doesn't exist and 1 in another case.
  280.         In the case of VIEW in tabid only field untabid is being filled.
  281.     
  282.       char  *tabnm;   * string containing table name        *
  283.                      
  284.       char  *owner;   * string containing user name         *
  285.       Tabid *tabid;   * answer parameter - table identifier *
  286.                       * if tabid == NULL,                   *
  287.                       * identifier isn't returned           *
  288.       char  *type;    * answer parameter - table type:      *
  289.                       * 'B' - base table , 'V' - view       */
  290. {
  291.   i4_t int_res;
  292.   char *tabtype;
  294.   CHECK_LEN (owner);
  295.   
  296.   IND_CLM_STR (0, tabnm);
  297.   IND_CLM_STR (1, owner);
  298.   RES_CLM (0, T_INT, SYSTABUNTABID);
  299.   RES_CLM (1, T_SRT, SYSTABSEGID);
  300.   RES_CLM (2, T_INT, SYSTABTABD);
  301.   RES_CLM (3, T_STR, SYSTABTABTYPE);
  303.   int_res = IND_READ (SYSTABLESIND1ID, 2, 4);
  304.   if (int_res < 0)
  305.     return 0;
  306.   
  307.   GET_RES_STR (3, tabtype);
  308.   if (type)
  309.     *type = tabtype[0];
  311.   if (tabid)
  312.     {
  313.       GET_RES_NUM (0, &(tabid->untabid));
  314.       if (tabtype[0] == 'B')    /* base table */
  315.         {
  316.           GET_RES_NUM (1, &(tabid->segid));
  317.           GET_RES_NUM (2, &(tabid->tabd));
  318.         }
  319.       else
  320.         {
  321.           assert (tabtype[0] == 'V'); /* view */
  322.           tabid->segid = tabid->tabd = 0;
  323.         }
  324.     }
  325.   return 1;
  326. } /* existtb */
  328. /*--------------------------------------------------------*/
  329. int
  330. existcl (Tabid * tabid, char *colnm, sql_type_t * type,
  331.          i4_t *colnumb, i4_t *def_func_id)
  332. /*
  333.   checking the existing of column  with given name in the pointed
  334.   table; column name has to be  simple; the result of function is
  335.   0 if this column exists, >0  if table exists but column doesn't
  336.   and result is <0 if given table doesn't exist
  337.   
  338.       Tabid      *tabid;    ;; table identifier                      
  339.       char       *colnm;    ;; column name                           
  340.       sql_type_t *type;     ;; answer parameter - column description 
  341.       i4_t        *colnumb;  ;; answer parameter - column number
  343. */
  344. {
  345.   i4_t int_res, collen, colprec;
  346.   i2_t numb;
  347.   char *coltype;
  349.   IND_CLM_STR (0, colnm);
  350.   IND_CLM_NUM (1, T_INT, &(tabid->untabid));
  351.   
  352.   RES_CLM (0, T_SRT, SYSCOLCOLNO);
  353.   RES_CLM (1, T_STR, SYSCOLCOLTYPE);
  354.   RES_CLM (2, T_INT, SYSCOLCOLTYPE1);
  355.   RES_CLM (3, T_INT, SYSCOLCOLTYPE2);
  356.   
  357.   int_res = IND_READ (SYSCOLUMNSIND1ID, 2, 4);
  358.   if (int_res < 0)
  359.     return int_res;
  360.   
  361.   GET_RES_NUM (0, &numb);
  362.   GET_RES_STR (1, coltype);
  363.   GET_RES_NUM (2, &collen);
  364.   GET_RES_NUM (3, &colprec);
  365.   
  366.   *colnumb  = numb;
  367.   *def_func_id = 0;
  368.   if (*coltype == SQLType_Char && colprec > 0)
  369.     {
  370.       *def_func_id = colprec;
  371.       colprec = 0;
  372.     }
  373.   *type = pack_type(*coltype,collen,colprec);
  374.   
  375.   return 0;
  376. }
  378. /*--------------------------------------------------------*/
  380. #define   STR_SAVE(to)                           
  381. {                                                
  382.   if (string)                                    
  383.     {                                            
  384.       to = GET_MEMC (char, strlen (string) + 1); 
  385.       strcpy (to, string);                       
  386.     }                                            
  387.   else                                           
  388.     to = NULL;                                   
  389. }
  391. int
  392. tab_cl (Tabid * tabid, i2_t clnm, sql_type_t * type, 
  393. char **cl_name, char **defval, char **defnull,
  394.         i4_t *def_func_id)
  395. /*
  396.   this  function gets information  about  column which number  is
  397.   clnm.  The function  result is 0  in the case of correct finish
  398.   of function and <0 if that table doesn't exist
  400.       Tabid *tabid;      ;; table identifier                   
  401.       i4_t    clnm;       ;; column number                      
  402.       sql_type_t  *type; ;; answer parameter - column description 
  404. */
  405. {
  406.   i4_t int_res, collen, colprec;
  407.   char *coltype, *string;
  408.   
  409.   IND_CLM_NUM (0, T_INT, &(tabid->untabid));
  410.   IND_CLM_NUM (1, T_SRT, &clnm);
  411.   
  412.   RES_CLM (0, T_STR, SYSCOLCOLNAME);
  413.   RES_CLM (1, T_STR, SYSCOLCOLTYPE);
  414.   RES_CLM (2, T_INT, SYSCOLCOLTYPE1);
  415.   RES_CLM (3, T_INT, SYSCOLCOLTYPE2);
  416.   RES_CLM (4, T_STR, SYSCOLDEFVAL);
  417.   RES_CLM (5, T_STR, SYSCOLDEFNULL);
  418.   
  419.   int_res = IND_READ (SYSCOLUMNSIND2ID, 2, 6);
  420.   if (int_res < 0)
  421.     return int_res;
  422.   
  423.   if (cl_name)
  424.     {
  425.       GET_RES_STR (0, string);
  426.       STR_SAVE (*cl_name);
  427.     }
  428.   GET_RES_STR (1, coltype);
  429.   GET_RES_NUM (2, &collen);
  430.   GET_RES_NUM (3, &colprec);
  431.   if (defval)
  432.     {
  433.       GET_RES_STR (4, string);
  434.       STR_SAVE (*defval);
  435.     }
  436.   if (defnull)
  437.     {
  438.       GET_RES_STR (5, string);
  439.       STR_SAVE (*defnull);
  440.       if (**defnull == '0')
  441. **defnull = 0;
  442.     }
  443.   if (def_func_id)
  444.     {
  445.       *def_func_id = 0;
  446.       if (*coltype == SQLType_Char && colprec > 0)
  447. {
  448.   *def_func_id = colprec;
  449.   colprec = 0;
  450. }
  451.     }
  452.   *type = pack_type(*coltype,collen,colprec);
  453.   
  454.   return 0;
  455. } /* tab_cl */
  457. /*--------------------------------------------------------*/
  458. int
  459. get_col_stat (i4_t untabid, i2_t clnm, col_stat_info *col_info)
  460.      /* function gets statistic information about column      *
  461.       * which number is clnm. The function result is 0 in the *
  462.       * case of correct finish of function and <0 if error    */
  463. {
  464.   i4_t int_res, collen, colprec;
  465.   char *coltype, *string;
  466.   
  467.   IND_CLM_NUM (0, T_INT, &untabid);
  468.   IND_CLM_NUM (1, T_SRT, &clnm);
  469.   
  470.   RES_CLM (0, T_STR, SYSCOLCOLTYPE);
  471.   RES_CLM (1, T_INT, SYSCOLCOLTYPE1);
  472.   RES_CLM (2, T_INT, SYSCOLCOLTYPE2);
  473.   RES_CLM (3, T_STR, SYSCOLMIN);
  474.   RES_CLM (4, T_STR, SYSCOLMAX);
  475.   
  476.   int_res = IND_READ (SYSCOLUMNSIND2ID, 2, 5);
  477.   if (int_res < 0)
  478.     return int_res;
  479.   
  480.   GET_RES_STR (0, coltype);
  481.   col_info->min.type.code = col_info->max.type.code = *coltype;
  482.   
  483.   GET_RES_NUM (1, &collen);
  484.   col_info->min.type.len = col_info->max.type.len = collen;
  485.   
  486.   GET_RES_NUM (2, &colprec);
  487.   col_info->min.type.prec = col_info->max.type.prec = colprec;
  488.   
  489.   GET_RES_STR (3, string);
  490.   mem_to_DU ((string) ? REGULAR_VALUE : NULL_VALUE, col_info->min.type.code,
  491.      (string) ? strlen (string) : 0, string, &(col_info->min));
  492.   
  493.   GET_RES_STR (4, string);
  494.   mem_to_DU ((string) ? REGULAR_VALUE : NULL_VALUE, col_info->max.type.code,
  495.      (string) ? strlen (string) : 0, string, &(col_info->max));
  496.   
  497.   return 0;
  498. } /* get_col_stat */
  500. /*--------------------------------------------------------*/
  501. static int
  502. DU_change_type (DataUnit *dt, i4_t tp_code)
  503. {
  504.   i4_t int_res = 0;
  505.   
  506.   if (dt->type.code != tp_code && dt->dat.nl_fl == REGULAR_VALUE)
  507.     {
  508.       int_res = put_dat (&VL(&(dt->dat)), 0, dt->type.code, 
  509.                          REGULAR_VALUE, &VL(&(dt->dat)), 0, tp_code, NULL);
  510.       dt->type.code = tp_code;
  511.     }
  512.   if (dt->type.len > MAX_STAT_LEN)
  513.     dt->type.len = MAX_STAT_LEN;
  514.     
  515.   return int_res;
  516. } /* DU_change_type */
  518. /*--------------------------------------------------------*/
  519. #define INS_min change_info->ins_min
  520. #define INS_max change_info->ins_max
  521. #define DEL_min change_info->del_min
  522. #define DEL_max change_info->del_max
  523. int
  524. put_col_stat (i4_t untabid, i2_t clnm, col_change_info *change_info)
  525.      /* modifies info in SYSCOLUMNS about MIN and/or MAX value in column. */
  526. {
  527.   static DataUnit null_val;
  528.   DataUnit du_arr[COLUMNS_COLNO];
  529.   DataUnit *new_min = NULL, *new_max = NULL;
  530.   i4_t mlist[2], nm = 0, int_res;
  531.   sql_type_t tp[2];
  532.   Scanid scanid = -1;
  533.   col_stat_info col_info;
  534.   i4_t error, col_nl_fl, ins_nl_fl, del_nl_fl;
  536.   bzero(&col_info,sizeof(col_info));
  538.   null_val.dat.nl_fl = NULL_VALUE;
  539.   
  540.   if (!change_info ||
  541.       (INS_min.dat.nl_fl == UNKNOWN_VALUE &&
  542.        INS_max.dat.nl_fl == UNKNOWN_VALUE &&
  543.        DEL_min.dat.nl_fl == UNKNOWN_VALUE &&
  544.        DEL_max.dat.nl_fl == UNKNOWN_VALUE))
  545.     return 0;
  546.   
  547.   if ((error = get_col_stat (untabid, clnm, &col_info)) < 0)
  548.     return error;
  550.   col_nl_fl = col_info.min.dat.nl_fl;
  551.   ins_nl_fl = INS_min.dat.nl_fl;
  552.   del_nl_fl = DEL_min.dat.nl_fl;
  553.   assert (col_nl_fl == col_info.max.dat.nl_fl &&
  554.           ins_nl_fl == INS_max.dat.nl_fl &&
  555.           del_nl_fl == DEL_max.dat.nl_fl);
  556.   /* making of new_min & new_max */
  557.   if (col_nl_fl == NULL_VALUE)
  558.     if (ins_nl_fl == REGULAR_VALUE)
  559.       /* insertion of not null value */
  560.       {
  561.         new_min = &(INS_min);
  562.         new_max = &(INS_max);
  563.       }
  564.     else {}
  565.   else
  566.     if (del_nl_fl == NULL_VALUE || ins_nl_fl == NULL_VALUE)
  567.       /* deletion or insertion of unknown value */
  568.       new_min = new_max = &null_val;
  569.     else
  570.       {
  571.         if (ins_nl_fl == REGULAR_VALUE)
  572.           {
  573.             MK_BIN_OPER (LT, INS_min, col_info.min);
  574.             if (COMP_RESULT)
  575.               {
  576.                 new_min = &(INS_min);
  577.                 col_info.min = INS_min;
  578.               }
  579.             MK_BIN_OPER (GT, INS_max, col_info.max);
  580.             if (COMP_RESULT)
  581.               {
  582.                 new_max = &(INS_max);
  583.                 col_info.max = INS_max;
  584.               }
  585.           }
  586.         if (del_nl_fl == REGULAR_VALUE)
  587.           {
  588.             i4_t lo=0,hi=0;
  589.             MK_BIN_OPER (LE, DEL_min, col_info.min);
  590.             if (COMP_RESULT) lo = 1 ;
  591.             MK_BIN_OPER (GE, DEL_max, col_info.max);
  592.             if (COMP_RESULT) hi = 1;
  593.             
  594. #if 0
  595.             if (lo) new_min = &null_val; /* conflict with assertation above */
  596.             if (hi) new_max = &null_val;
  597. #else
  598.             if ( lo && hi )
  599.               new_min = new_max = &null_val;
  600. #endif
  601.           }
  602.       }
  604.   if (new_min || new_max)
  605.     {
  606.       bzero (du_arr, sizeof (DataUnit) * COLUMNS_COLNO);
  607.       IND_CLM_NUM (0, T_INT, &untabid);
  608.       IND_CLM_NUM (1, T_SRT, &clnm);
  609.   
  610.       if ((int_res = IND_UPD_READ (SYSCOLUMNSIND2ID, 2, 0)))
  611.         return int_res;
  612.   
  613.       if (new_min)
  614.         {
  615.           DU_change_type (new_min, col_info.min.type.code);
  616.           mlist[nm] = SYSCOLMIN;
  617.           conv_DU_to_str (new_min, du_arr + SYSCOLMIN);
  618.           tp[nm++] = du_arr[SYSCOLMIN].type;
  619.         }
  620.       if (new_max)
  621.         {
  622.           DU_change_type (new_max, col_info.min.type.code);
  623.           mlist[nm] = SYSCOLMAX;
  624.           conv_DU_to_str (new_max, du_arr + SYSCOLMAX);
  625.           tp[nm++] = du_arr[SYSCOLMAX].type;
  626.         }
  627.   
  628.       if ((int_res = mod_data (scanid, nm, du_arr, tp, NULL, mlist)))
  629.         return int_res;
  630.       closescan (scanid);
  631.     }
  632.   return 0;
  633. } /* put_col_stat */
  634. #undef INS_min
  635. #undef INS_max
  636. #undef DEL_min
  637. #undef DEL_max
  639. /*--------------------------------------------------------*/
  640. int
  641. tabclnm (Tabid * tabid, i4_t *nnulcolnum)
  642.      /* this function gets the number of columns in pointed table;
  643. the result of function is this number (>0)
  644. or negative if table doesn't exist
  645.   
  646.       Tabid *tabid;        * table identifier          */
  647. {
  648.   i4_t int_res;
  649.   i2_t ncols; /* the number of columns   */
  650.   
  651.   assert (nnulcolnum);
  652.   IND_CLM_NUM (0, T_INT, &(tabid->untabid));
  653.   RES_CLM (0, T_SRT, SYSTABNCOLS);
  654.   RES_CLM (1, T_INT, SYSTABNNULCOLNUM);
  656.   int_res = IND_READ (SYSTABLESIND2ID, 1, 2);
  657.   if (int_res < 0)
  658.     return int_res;
  659.   
  660.   GET_RES_NUM (0, &ncols);
  661.   GET_RES_NUM (1, nnulcolnum);
  662.   
  663.   return ncols;
  664. } /* tabclnm */
  666. /*--------------------------------------------------------*/
  667. int
  668. get_nrows (i4_t untabid)
  669.      /* function gets the number of rows in table; *
  670.       * the result of function is this number (>0) *
  671.       * or negative if table doesn't exist         */
  672. {
  673.   i4_t int_res, nrows;
  674.   
  675.   IND_CLM_NUM (0, T_INT, &untabid);
  676.   RES_CLM (0, T_INT, SYSTABNROWS);
  678.   if ((int_res = IND_READ (SYSTABLESIND2ID, 1, 1)))
  679.     return int_res;
  680.   
  681.   GET_RES_NUM (0, &nrows);
  682.   
  683.   return nrows;
  684. } /* get_nrows */
  686. /*--------------------------------------------------------*/
  687. int
  688. put_nrows (i4_t untabid, i4_t nrows)
  689. /* modifies info in SYSTABLES about rows number in table */
  690. {
  691.   i4_t mlist = SYSTABNROWS, int_res;
  692.   sql_type_t tp;
  693.   DataUnit du_arr[TABLES_COLNO];
  694.   Scanid scanid = -1;
  695.   
  696.   tp = pack_type(T_INT,0,0);
  697.   
  698.   bzero (du_arr, sizeof (DataUnit) * TABLES_COLNO);
  699.   IND_CLM_NUM (0, T_INT, &untabid);
  700.   
  701.   if ((int_res = IND_UPD_READ (SYSTABLESIND2ID, 1, 0)))
  702.     return int_res;
  703.   
  704.   du_arr[SYSTABNROWS].type = tp;
  705.   mem_to_DU (REGULAR_VALUE, T_INT, 0, &nrows, du_arr + SYSTABNROWS);
  706.   if ((int_res = mod_data (scanid, 1, du_arr, &tp, NULL, &mlist)))
  707.     return int_res;
  708.   closescan (scanid);
  709.   return 0;
  710. } /* put_nrows */
  712. /*--------------------------------------------------------*/
  713. int
  714. get_tabid (i4_t untabid, Tabid *tabid)
  715.      /* this function gets all fields of tabid for table with this untabid *
  716.       * The result is 0 if o'k or negative if table doesn't exist          */
  717. {
  718.   i4_t int_res;
  719.   
  720.   IND_CLM_NUM (0, T_INT, &untabid);
  721.   RES_CLM (0, T_SRT, SYSTABSEGID);
  722.   RES_CLM (1, T_INT, SYSTABTABD);
  724.   int_res = IND_READ (SYSTABLESIND2ID, 1, 2);
  725.   if (int_res < 0)
  726.     return int_res;
  727.   
  728.   tabid->untabid = untabid;
  729.   GET_RES_NUM (0, &(tabid->segid));
  730.   GET_RES_NUM (1, &(tabid->tabd));
  731.   
  732.   return 0;
  733. } /* tabclnm */
  735. /*--------------------------------------------------------*/
  737. #define SEE_PVLG(type, j)                         
  738. {                                                 
  739.   u_need = r_need = 0;                            
  740.   for (i = 0, j = 1; (acttype[i]) && (j!=2); i++) 
  741.     if (!strchr (type, acttype[i]))               
  742.       switch (acttype[i])                         
  743. {                                         
  744. case 'U' :                                
  745.   if (un)                                 
  746.     if (strchr (type, 'u'))               
  747.       { j = 0; u_need ++; break; }        
  748.   j = 2;                                  
  749.   break;                                  
  750. case 'R' :                                
  751.   if (rn)                                 
  752.     if (strchr (type, 'r'))               
  753.       { j = 0; r_need ++; break; }        
  754.   j = 2;                                  
  755.   break;                                  
  756. default :                                 
  757.   j = 2;                                  
  758. }                                         
  759. }
  761. int
  762. tabpvlg (i4_t untabid, char *user, char *acttype,
  763.  i4_t un, i4_t *ulist,i4_t rn, i4_t *rlist)
  764. /*
  765. * checking access privilegies
  766. i4_t untabid   - table identifier
  767. char *user    - user name
  768. char *acttype - string with the following codes:
  769.                       * 'S' - SELECT,                     *
  770.                       * 'D' - DELETE,                     *
  771.       * 'U' - UPDATE,                     *
  772.       * 'I' - INSERT,                     *
  773.       * 'R' - REFERENCES                  *
  774.       * 'G' - GRANT OPTION                *
  775. i4_t un       - the number of rows to which the act "update"
  776.                is applied      
  777. i4_t *ulist   - array of column number to which the act "update"
  778.                is applied
  779. i4_t rn,      - the number of rows for which the act REFERENCES
  780.        is applied
  781. i4_t *rlist   - array of rows for which the act REFERENCES
  782.        is applied                                    */
  784. {
  785.   /* in SYSTABAUTH.tabauth : 'S','D','U','I','R','G' - rights *
  786.    * on all columns of table. 'u' and 'r' - there are not     *
  787.    * full rights but in table SYSCOLAUTH are described        *
  788.    * rights on some (not all) columns.                        */
  789.   
  790.   i4_t i, j, pvlg, u_need, r_need, int_res, int_res1;
  791.   char type[MAX_COLNO], *type1 = NULL, *type2 = NULL;
  792.   i2_t colno;
  793.   char * public = "PUBLIC";
  794.   
  795.   type[0] = 0;
  796.   CHECK_LEN (user);
  797.   
  798.   IND_CLM_NUM (0, T_INT, &untabid);
  799.   IND_CLM_STR (1, user);
  800.   RES_CLM (0, T_STR, SYSTABAUTHTABAUTH);
  801.   
  802.   int_res = IND_READ (SYSTABAUTHIND1ID, 2, 1);
  803.   
  804.   if (!int_res)
  805.     /* there are previlegies on the table for this user */
  806.     {
  807.       GET_RES_STR (0, type1);
  808.       SEE_PVLG (type1, pvlg);
  809.       /* pvlg == 0 => we should check information for columns    *
  810.        * pvlg == 1 => all wanted user rights were found          *
  811.        * pvlg == 2 => user have not all wanted rights            */
  812.       if (pvlg == 1)
  813. return 0;
  814.     }
  815.   if (type1)
  816.     strcpy (type, type1);
  817.   
  818.   IND_CLM_STR (1, public);
  819.   
  820.   int_res1 = IND_READ (SYSTABAUTHIND1ID, 2, 1);
  821.   if (int_res && int_res1)
  822.     return int_res;
  823.   if (!int_res1)
  824.     {
  825.       GET_RES_STR (0, type2);
  826.       if (type2)
  827. strcpy (type + strlen (type), type2);
  828.     }
  830.   SEE_PVLG (type, pvlg);
  831.   if (pvlg)
  832.     return pvlg - 1;
  833.   
  834. /*    check  rights UPDATE  or | and  REFERENCES for columns */
  835.   
  836.   IND_CLM_NUM (0, T_INT, &untabid);
  837.   IND_CLM_STR (2, user);
  838.   RES_CLM (0, T_STR, SYSCOLAUTHCOLAUTH);
  840.   if (u_need)
  841.     for (j = 0; j < un; j++)
  842.       {
  843. colno = ulist[j];
  844. IND_CLM_NUM (1, T_SRT, &colno);
  845. int_res = IND_READ (SYSCOLAUTHIND1ID, 3, 1);
  846. GET_RES_STR (0, type1);
  847.       
  848. if (int_res || !strchr (type1, 'U'))
  849.   return 1;
  850.       }
  851.   
  852.   if (r_need)
  853.     for (j = 0; j < rn; j++)
  854.       {
  855. colno = rlist[j];
  856. IND_CLM_NUM (1, T_SRT, &colno);
  857. int_res = IND_READ (SYSCOLAUTHIND1ID, 3, 1);
  858. GET_RES_STR (0, type1);
  859.       
  860. if (int_res || !strchr (type1, 'R'))
  861.   return 1;
  862.       }
  863.   
  864.   return 0;
  865. } /* tabpvlg */
  867. static TXTREF
  868. get_table(Tabid *tabid)
  869. {
  870.   extern void load_table __P((TXTREF ptbl));
  871.   TXTREF t;
  872.   for ( t = *(Root_ptr(Vcb_Root)); t ; t = RIGHT_TRN(t))
  873.     {
  874.       if (CODE_TRN(t) == ANY_TBL)
  875. load_table(t);
  876.       if ( (CODE_TRN(t) == TABLE) && ((TBL_TABID(t)).untabid == tabid->untabid))
  877. return t;
  878.     }
  879.   /* get_table_name for given tabid, create ANY_TBL and load_table */
  880.   return TNULL;
  881. }
  883. #define      INDFM  pind->Ind
  885. /* Checking of index existence for pointed table.
  886.    Function returns NULL when there are no indexes for
  887.    pointed table or pointer for list of index descriptions */
  889. TXTREF
  890. existind (Tabid * tabid)
  891. {
  892.   i2_t ncol;
  893.   i4_t i, int_res;
  894.   Indid  indid;
  895.   char *inxtype;
  896.   Scanid scanid = -1;
  897.   TXTREF ind_list = TNULL,tbl, cptrs;
  898.   
  899.   indid.tabid = *tabid;
  900.   
  901.   tbl = get_table(tabid);
  902.   if (!tbl)
  903.     return TNULL;
  904.   
  905.   IND_CLM_NUM (0, T_INT, &(tabid->untabid));
  906.   
  907.   RES_CLM (0,  T_STR, SYSINDEXTYPE);
  908.   RES_CLM (1,  T_SRT, SYSINDEXNCOL);
  909.   RES_CLM (2,  T_INT, SYSINDEXUNINDID);
  910.   RES_CLM (3,  T_SRT, SYSINDEXCOLNO1);
  911.   RES_CLM (4,  T_SRT, SYSINDEXCOLNO2);
  912.   RES_CLM (5,  T_SRT, SYSINDEXCOLNO3);
  913.   RES_CLM (6,  T_SRT, SYSINDEXCOLNO4);
  914.   RES_CLM (7,  T_SRT, SYSINDEXCOLNO5);
  915.   RES_CLM (8,  T_SRT, SYSINDEXCOLNO6);
  916.   RES_CLM (9,  T_SRT, SYSINDEXCOLNO7);
  917.   RES_CLM (10, T_SRT, SYSINDEXCOLNO8);
  918.   
  919.   for (;;)
  920.     {
  921.       cptrs = TNULL;
  922.       int_res = IND_NEXT_READ (SYSINDEXIND, 1, 11);
  923.       if (int_res < 0)
  924.         break;
  925.       
  926.       GET_RES_STR (0, inxtype);
  927.       GET_RES_NUM (1, &ncol);
  928.       GET_RES_NUM (2, &indid.unindid);
  929.       
  930.       for (i = ncol; i--;)
  931. {
  932.   i2_t col_no;
  933.   TXTREF cptr;
  934.   
  935.   GET_RES_NUM (3 + i, &col_no);
  936.   cptr = gen_colptr(find_column_by_number(tbl,col_no));
  937.   RIGHT_TRN(cptr) = cptrs;
  938.   cptrs = cptr;
  939. }
  940.       
  941.       {
  942. TXTREF ind;
  943. enum token code = INDEX;
  945. if (inxtype)
  946.           switch (inxtype[0])
  947.             {
  948.             case 'U' :
  949.               code = UNIQUE;
  950.               break;
  951.             case 'P' :
  952.               code = PRIMARY;
  953.               break;
  954.             default  :
  955.               break;
  956.             }
  957. ind = gen_parent(code,cptrs);
  958. /* assert(ARITY_TRN(ind) == ncol); */
  959. IND_INDID(ind) = indid;
  960. ind_list = join_list(ind_list,ind);
  961.       }
  962.     }/* for */
  963.   return ind_list;
  964. } /* existind */
  966. #define SAVE_CONSTR                           
  967. {                                             
  968.   if (pred_constr != NULL)                    
  969.     pred_constr->next = cur_constr;           
  970.   else                                        
  971.     constr_list = cur_constr;                 
  972.   pred_constr = cur_constr;                   
  973. }
  975. int
  976. new_ref_to_ind (Tabid *tabid, i2_t ncol, char *columns_fl, Scanid scanid)
  977.      /* searching for index to scan for costraint checking *
  978.       * and putting its identifier to SYSREFCONSTR         */
  979. {
  980.   TXTREF cur_ind, CurIndCol;
  981.   i4_t unindid, spn, mlist = SYSREFCONSTRINDTO;
  982.   sql_type_t tp;
  983.   DataUnit du_arr[SYSREFCONSTRINDTO+1];
  984.   
  985.   tp = pack_type(T_INT, 0, 0);
  986.   bzero (du_arr, sizeof (DataUnit) * (SYSREFCONSTRINDTO+1));
  987.   for (cur_ind = existind (tabid); cur_ind; cur_ind = RIGHT_TRN (cur_ind))
  988.     if (ARITY_TRN (cur_ind) == ncol)
  989.       {
  990.         i4_t eq_num = ncol;
  991. for (CurIndCol = DOWN_TRN (cur_ind);
  992.      CurIndCol; CurIndCol = RIGHT_TRN (CurIndCol))
  993.   if (columns_fl[COL_NO (OBJ_DESC (CurIndCol))])
  994.     eq_num--;
  995. if (!eq_num)
  996.   break;
  997.       }
  998.   
  999.   if (!cur_ind)
  1000.     yyfatal ("Incorrect state of database: there is no index for columns from constraint");
  1001.   
  1002.   unindid = (IND_INDID (cur_ind)).unindid;
  1003.   
  1004.   du_arr[SYSREFCONSTRINDTO].type = tp;
  1005.   mem_to_DU (REGULAR_VALUE, T_INT, 0, &unindid, du_arr + SYSREFCONSTRINDTO);
  1006.   mod_data (scanid, 1, du_arr, &tp, &spn, &mlist);
  1007.   return unindid;
  1008. }
  1010. Constr_Info *
  1011. get_constraints (i4_t untabid, i4_t tab_clm_num)
  1012. /* Gets information about constraints to table. *
  1013.  * Returns the list constraints descriptions    *
  1014.  * (it can be = NULL if the list is empty).     */
  1015. {
  1016.   i2_t ncol, cur_col;
  1017.   i4_t *columns_from, *columns_to;
  1018.   i4_t i, int_res, ref_untabid, ref_ind;
  1019.   Constr_Info *constr_list = NULL, *cur_constr, *pred_constr = NULL;
  1020.   VADR V_constr_ptr, V_ref_tabid, V_columns_from, V_columns_to, V_ref_indid;
  1021.   S_Constraint *constr_ptr;
  1022.   Tabid *ref_tabid;
  1023.   Indid *ref_indid;
  1024.   Scanid scanid = -1;
  1025.   
  1026.   /* checking when this table is referencing : */
  1027.   
  1028.   for (;;)
  1029.     {
  1030.       IND_CLM_NUM (0,  T_INT, &(untabid));
  1031.   
  1032.       RES_CLM (0,  T_INT, SYSREFCONSTRTABTO);
  1033.       RES_CLM (1,  T_SRT, SYSREFCONSTRNCOLS);
  1034.       RES_CLM (2,  T_SRT, SYSREFCONSTRCOLNOFR1);
  1035.       RES_CLM (3,  T_SRT, SYSREFCONSTRCOLNOFR2);
  1036.       RES_CLM (4,  T_SRT, SYSREFCONSTRCOLNOFR3);
  1037.       RES_CLM (5,  T_SRT, SYSREFCONSTRCOLNOFR4);
  1038.       RES_CLM (6,  T_SRT, SYSREFCONSTRCOLNOFR5);
  1039.       RES_CLM (7,  T_SRT, SYSREFCONSTRCOLNOFR6);
  1040.       RES_CLM (8,  T_SRT, SYSREFCONSTRCOLNOFR7);
  1041.       RES_CLM (9,  T_SRT, SYSREFCONSTRCOLNOFR8);
  1042.       RES_CLM (10, T_SRT, SYSREFCONSTRCOLNOTO1);
  1043.       RES_CLM (11, T_SRT, SYSREFCONSTRCOLNOTO2);
  1044.       RES_CLM (12, T_SRT, SYSREFCONSTRCOLNOTO3);
  1045.       RES_CLM (13, T_SRT, SYSREFCONSTRCOLNOTO4);
  1046.       RES_CLM (14, T_SRT, SYSREFCONSTRCOLNOTO5);
  1047.       RES_CLM (15, T_SRT, SYSREFCONSTRCOLNOTO6);
  1048.       RES_CLM (16, T_SRT, SYSREFCONSTRCOLNOTO7);
  1049.       RES_CLM (17, T_SRT, SYSREFCONSTRCOLNOTO8);
  1050.       RES_CLM (18, T_INT, SYSREFCONSTRINDTO);
  1051.   
  1052.       int_res = IND_UPD_READ (SYSREFCONSTRINDEX, 1, 19);
  1053.       if (int_res < 0)
  1054. break;
  1055.   
  1056.       cur_constr = GET_MEMC (Constr_Info, 1);
  1057.       cur_constr->next = NULL;
  1058.       cur_constr->mod_cols = GET_MEMC (char, tab_clm_num);
  1059.       P_VMALLOC (constr_ptr, 1, S_Constraint);
  1060.       cur_constr->constr = V_constr_ptr;
  1061.       constr_ptr->constr_type = cur_constr->constr_type = FOREIGN;
  1062.       
  1063.       GET_RES_NUM (0,  &ref_untabid);
  1064.       GET_RES_NUM (1,  &ncol);
  1065.       GET_RES_NUM (18, &ref_ind);
  1066.       
  1067.       P_VMALLOC (columns_from, ncol, i4_t);
  1068.       P_VMALLOC (columns_to,   ncol, i4_t);
  1069.       constr_ptr->col_arg_list = V_columns_from;
  1070.       constr_ptr->col_ref_list = V_columns_to;
  1071.       constr_ptr->colnum = ncol;
  1072.       assert(ncol<=8 && ncol<=tab_clm_num);
  1074.       for (i = 0; i < ncol; i++)
  1075. {
  1076.   GET_RES_NUM (2 + i, &cur_col);
  1077.           assert(cur_col<tab_clm_num);
  1078.   columns_from[i] = cur_col;
  1079.   GET_RES_NUM (10 + i, &cur_col);
  1080.   columns_to[i] = cur_col;
  1081.   (cur_constr->mod_cols)[columns_to[i]] = TRUE;
  1082. }
  1083.       
  1084.       P_VMALLOC (ref_indid, 1, Indid);
  1085.       constr_ptr->object = V_ref_indid;
  1086.       get_tabid (ref_untabid, &(ref_indid->tabid));
  1087.       ref_indid->unindid = (ref_ind) ? ref_ind :
  1088. new_ref_to_ind (&(ref_indid->tabid), ncol, cur_constr->mod_cols, scanid);
  1089.       
  1090.       SAVE_CONSTR;
  1091.     } /* for */
  1092.   
  1093.   /* checking when this table is referenced : */
  1094.   
  1095.   for (;;)
  1096.     {
  1097.       IND_CLM_NUM (0,  T_INT, &(untabid));
  1098.       
  1099.       RES_CLM (0,  T_INT, SYSREFCONSTRTABFROM);
  1100.       RES_CLM (1,  T_SRT, SYSREFCONSTRNCOLS);
  1101.   
  1102.       int_res = IND_NEXT_READ (SYSREFCONSTRIND1, 1, 18);
  1103.       if (int_res < 0)
  1104. break;
  1105.   
  1106.       cur_constr = GET_MEMC (Constr_Info, 1);
  1107.       cur_constr->next = NULL;
  1108.       cur_constr->mod_cols = GET_MEMC (char, tab_clm_num);
  1109.       P_VMALLOC (constr_ptr, 1, S_Constraint);
  1110.       cur_constr->constr = V_constr_ptr;
  1111.       constr_ptr->constr_type = cur_constr->constr_type = REFERENCE;
  1112.       
  1113.       GET_RES_NUM (0,  &ref_untabid);
  1114.       GET_RES_NUM (1,  &ncol);
  1115.       assert(ncol<=8 && ncol<=tab_clm_num);
  1116.       
  1117.       P_VMALLOC (columns_from, ncol, i4_t);
  1118.       P_VMALLOC (columns_to,   ncol, i4_t);
  1119.       constr_ptr->col_arg_list = V_columns_from;
  1120.       constr_ptr->col_ref_list = V_columns_to;
  1121.       constr_ptr->colnum = ncol;
  1123.       for (i = 0; i < ncol; i++)
  1124. {
  1125.   GET_RES_NUM (10 + i, &cur_col);
  1126.           assert(cur_col<tab_clm_num);
  1127.   columns_from[i] = cur_col;
  1128.   GET_RES_NUM (2 + i, &cur_col);
  1129.   columns_to[i] = cur_col;
  1130.   (cur_constr->mod_cols)[columns_from[i]] = TRUE;
  1131. }
  1132.       
  1133.       P_VMALLOC (ref_tabid, 1, Tabid);
  1134.       constr_ptr->object = V_ref_tabid;
  1135.       get_tabid (ref_untabid, ref_tabid);
  1136.       
  1137.       SAVE_CONSTR;
  1138.     } /* for */
  1139.       
  1140.   IND_CLM_NUM (0,  T_INT, &(untabid));
  1141.   
  1142.   RES_CLM (0,  T_INT, SYSCHCONSTRCHCONID);
  1143.   RES_CLM (1,  T_INT, SYSCHCONSTRCONSIZE);
  1144.   RES_CLM (2,  T_SRT, SYSCHCONSTRNCOLS);
  1145.   RES_CLM (3,  T_SRT, SYSCHCONSTRCOLNO1);
  1146.   RES_CLM (4,  T_SRT, SYSCHCONSTRCOLNO2);
  1147.   RES_CLM (5,  T_SRT, SYSCHCONSTRCOLNO3);
  1148.   RES_CLM (6,  T_SRT, SYSCHCONSTRCOLNO4);
  1149.   RES_CLM (7,  T_SRT, SYSCHCONSTRCOLNO5);
  1150.   RES_CLM (8,  T_SRT, SYSCHCONSTRCOLNO6);
  1151.   RES_CLM (9,  T_SRT, SYSCHCONSTRCOLNO7);
  1152.   RES_CLM (10, T_SRT, SYSCHCONSTRCOLNO8);
  1153.   
  1154.   /* finding of all 'CHECK' constraints for this table : */
  1155.   
  1156.   for (;;)
  1157.     {
  1158.       int_res = IND_NEXT_READ (SYSCHCONSTRINDEX, 1, 11);
  1159.       if (int_res < 0)
  1160. break;
  1161.   
  1162.       cur_constr = GET_MEMC (Constr_Info, 1);
  1163.       cur_constr->next = NULL;
  1164.       cur_constr->mod_cols = GET_MEMC (char, tab_clm_num);
  1165.       cur_constr->constr = VNULL;
  1166.       cur_constr->constr_type = CHECK;
  1167.       
  1168.       GET_RES_NUM (0,  &(cur_constr->conid));
  1169.       GET_RES_NUM (1,  &(cur_constr->consize));
  1170.       GET_RES_NUM (2,  &ncol);
  1171.       assert(ncol<=8 && ncol<=tab_clm_num);
  1172.       
  1173.       for (i = 0; i < ncol; i++)
  1174. {
  1175.   GET_RES_NUM (3 + i, &cur_col);
  1176.           assert(cur_col<tab_clm_num);
  1177.   (cur_constr->mod_cols)[cur_col] = TRUE;
  1178. }
  1179.       
  1180.       SAVE_CONSTR;
  1181.     } /* for */
  1183.   return constr_list;
  1184. } /* get_constraints */
  1186. char *
  1187. get_chconstr (i4_t chconid, i4_t consize)
  1188.      /* gets the string for 'CHECK' constraint with identifier 'chconid' */
  1189. {
  1190.   char *string = NULL, *frag, *cur_in_string;
  1191.   i2_t fragno;
  1192.   i4_t int_res, fragsize;
  1193.   
  1194.   IND_CLM_NUM (0, T_INT, &chconid);
  1195.   RES_CLM (0, T_INT, SYSCHCONSTR2FRAGSIZE);
  1196.   RES_CLM (1, T_STR, SYSCHCONSTR2FRAG);
  1197.   
  1198.   cur_in_string = string = GET_MEMC (char, consize);
  1199.   
  1200.   for (fragno = 0; ; fragno++)
  1201.     {
  1202.       IND_CLM_NUM (1, T_SRT, &fragno);
  1203.       
  1204.       int_res = IND_READ (SYSCHCONSTRTWOIND, 2, 2);
  1205.       if (int_res < 0)
  1206. break;
  1207.       
  1208.       GET_RES_NUM (0, &fragsize);
  1209.       GET_RES_STR (1, frag);
  1210.       bcopy (frag, cur_in_string, fragsize);
  1211.       cur_in_string += fragsize;
  1212.     }
  1213.   assert (cur_in_string - string == consize);
  1214.   return string;
  1215. } /* get_chconstr */
  1217. /*--------------------------------------------------------*/
  1218. int
  1219. getview (i4_t untabid, char **res_segm)
  1220. /*
  1221.   receiving the  syntax tree  of view. Function returns
  1222.   the summary  size of memory  (in byte)>=0 in the case of
  1223.   success or negative value when the view doesn't exist.
  1224.    
  1225.       i4_t    untabid;   * unique view identifier              *
  1226.       char  **res_segm; * array of bytes with lenght "size"   *
  1227.                         *  which is used as answer parameter  *
  1228.                         *  of function.                       *
  1229. */
  1230. {
  1231.   static char  *buf = NULL;
  1232.   static i4_t    buf_size = 0;
  1233.   i4_t   size = 0, int_res, fragsize;
  1234.   i2_t fragno;
  1235.   char *frag;
  1236.   
  1237.   IND_CLM_NUM(0, T_INT, &untabid);
  1239.   RES_CLM ( 0, T_INT, SYSVIEWSFRAGSIZE);
  1240.   RES_CLM ( 1, T_STR, SYSVIEWSFRAG);
  1242.   for (fragno = 0; ; fragno++)
  1243.     {
  1244.       IND_CLM_NUM (1, T_SRT, &fragno);
  1245.       
  1246.       int_res = IND_READ (SYSVIEWSIND, 2, 2);
  1247.       if (int_res < 0)
  1248. break;
  1249.       
  1250.       GET_RES_NUM (0, &fragsize);
  1251.       size += fragsize;
  1252.       CHECK_ARR_ELEM (buf, buf_size, size, size, char);
  1253.       GET_RES_STR (1, frag);
  1254.       bcopy (frag, buf + size - fragsize, fragsize);
  1255.     }
  1257.   *res_segm = buf;
  1258.   return size;
  1259. }
  1261. #define DO(x) {if ((int_res = x)) return int_res;}
  1263. #define IND_DELROWS(ind, tab)             
  1264. {
  1265.   while (IND_DEL_READ (ind, 1, 0) >= 0)         
  1266.     {          
  1267.       handle_statistic (SYS##tab.untabid, tab##_COLNO, 0, NULL, 0); 
  1268.       DO (delrow (scanid, &spn));
  1269.     }          
  1270.   if (scanid >= 0)
  1271.     closescan (scanid);
  1272.   scanid = -1;
  1273. }
  1275. int
  1276. drop_table (i4_t untabid)
  1277. {
  1278.   Scanid scanid = -1, sv_scanid;
  1279.   char *tabtype;
  1280.   i4_t spn, int_res, conid;
  1281.   Tabid tabid;
  1283.   if (get_tabid (untabid, &tabid))
  1284.     return -NDR;
  1286.   /* references checking */
  1287.   IND_CLM_NUM (0, T_INT, &untabid);
  1288.   if (IND_READ (SYSREFCONSTRIND1, 1, 0) >= 0)
  1289.     /* there are still references to this table */
  1290.     return -ER_DRTAB;
  1291.   
  1292.   /* SYSTABLES handling */
  1293.   RES_CLM (0, T_STR, SYSTABTABTYPE);
  1294.   
  1295.   if (IND_DEL_READ (SYSTABLESIND2ID, 1, 1))
  1296.     return -NDR;
  1297.   GET_RES_STR (0, tabtype);
  1298.   if (tabtype[0] == 'B')    /* base table */
  1299.     DO (dropptab (&tabid, &spn))
  1300.   else
  1301.     {
  1302.       sv_scanid = scanid;
  1303.       scanid = -1;
  1304.       IND_DELROWS (SYSVIEWSIND, VIEWS);
  1305.       scanid = sv_scanid;
  1306.     }
  1307.   DO (delrow (scanid, &spn));
  1308.   handle_statistic (SYSTABLES.untabid, TABLES_COLNO, 0, NULL, 0);
  1309.   closescan (scanid);
  1310.   scanid = -1;
  1311.   
  1312.   IND_CLM_NUM (0, T_INT, &untabid);
  1313.   
  1314.   IND_DELROWS (SYSCOLUMNSIND2ID,  COLUMNS);
  1315.   IND_DELROWS (SYSCOLAUTHIND1ID,  COLAUTH);
  1316.   IND_DELROWS (SYSTABAUTHIND1ID,  TABAUTH);
  1317.   IND_DELROWS (SYSINDEXIND,       INDEXES);
  1318.   IND_DELROWS (SYSREFCONSTRINDEX, REFCONSTR);
  1320.   /* handling of tables with info about CHECK constraints */
  1321.   RES_CLM (0, T_INT, SYSCHCONSTRCHCONID);
  1322.   while (IND_DEL_READ (SYSCHCONSTRINDEX, 1, 1) >= 0)
  1323.     {
  1324.       GET_RES_NUM (0,  &conid);
  1325.       IND_CLM_NUM (0, T_INT, &conid);
  1326.       sv_scanid = scanid;
  1327.       scanid = -1;
  1328.       IND_DELROWS (SYSTABAUTHIND1ID, TABAUTH);
  1329.       scanid = sv_scanid;
  1330.       
  1331.       DO (delrow (scanid, &spn));
  1332.       handle_statistic (SYSCHCONSTR.untabid,
  1333.                         CHCONSTR_COLNO, 0, NULL, 0);
  1334.       IND_CLM_NUM (0, T_INT, &untabid);
  1335.     }
  1336.   if (scanid >= 0)
  1337.     closescan (scanid);
  1338.   return 0;
  1339. } /* drop_table */
  1341. #undef DO
  1342. #undef IND_DELROWS
  1344. /**************** THE E N D ****************/