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

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

SQL Server

开发平台：

Unix_Linux

type_lib.c：源码内容
  1. /*
  2.  *  type_lib.c  -  types library of GNU SQL server
  3.  *
  4.  *  This file is a part of GNU SQL Server
  5.  *
  6.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  7.  *  Developed at the Institute of System Programming
  8.  *  This file is written by Konstantin Dyshlevoi.
  9.  *
  10.  *  This program is free software; you can redistribute it and/or modify
  11.  *  it under the terms of the GNU General Public License as published by
  12.  *  the Free Software Foundation; either version 2 of the License, or
  13.  *  (at your option) any later version.
  14.  *
  15.  *  This program is distributed in the hope that it will be useful,
  16.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *  GNU General Public License for more details.
  19.  *
  20.  *  You should have received a copy of the GNU General Public License
  21.  *  along with this program; if not, write to the Free Software
  22.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  *
  24.  *  Contacts: gss@ispras.ru
  25.  *
  26.  */
  28. /* $Id: type_lib.c,v 1.247 1997/04/06 17:36:02 kml Exp $ */
  30. #include <assert.h>
  32. #include "global.h"
  33. #include "type_lib.h"
  34. #include "inprtyp.h"
  35. #include "sql.h"
  36. #include "totdecl.h"
  37. #include "fieldtp.h"
  39. extern DataUnit *ins_col_values;
  40. DataUnit *data_st = NULL;
  41. i4_t   dt_ind, dt_max;
  43. i4_t res_hole_cnt = 0;
  44. parm_t *res_hole = NULL;
  46. /* In all leafs field Ptr points to element of type DataUnit      *
  47.  * where the type of the value is filled by codegen.              */
  49. /* Type of result of subtree must be put into all according nodes *
  50.  * ( if it's the logic value =>  T_BOOL).                         *
  51.  * in nodes for subquery :.Rh- reference to programm for          *
  52.  * handling this subquery.                                        */
  54. #define CHECK_FLAG(du)                  
  55.   if ((du).dat.nl_fl == NOT_CONVERTED)                 
  56.   {                 
  57.     STR_PTR (&((du).dat)) = V_PTR (STR_VPTR (&((du).dat)), char); 
  58.     (du).dat.nl_fl = REGULAR_VALUE;                 
  59.   }
  61. short
  62. sizeof_sqltype (sql_type_t type)
  63. /* values' lenght of this type */
  64. {
  65.   i2_t res;
  66.   switch (type.code)
  67.     {
  68.     case T_SRT:
  69.       res = SZ_SHT;
  70.       break;
  71.     case T_INT:
  72.       res = SZ_INT;
  73.       break;
  74.     case T_LNG:
  75.       res = SZ_LNG;
  76.       break;
  77.     case T_FLT:
  78.       res = SZ_FLT;
  79.       break;
  80.     case T_DBL:
  81.       res = SZ_DBL;
  82.       break;
  83.     case T_STR:
  84.       res = type.len;
  85.       break;
  86.     default:
  87.       res = 0;
  88.       lperror ("Unexpected expression type '%s'", type2str(type));
  89.     }
  90.   return res;
  91. }
  93. VADR
  94. load_tree (TRNode *node, VADR cur_seg, VADR str_seg)
  95.      /* recursive function for copying the tree      *
  96.       * for CHECK constraint from temporary segment  *
  97.       * to current working segment of virtual memory */
  98. {
  99.   VADR V_res_node, V_ptr = VNULL, V_Dn, V_Rh;
  100.   TRNode *res_node;
  101.   TRNode *Rh_old, *Dn_old;
  102.   DataUnit *du = NULL;
  103.   TpSet *dat = NULL;
  104.   char *str_dat = NULL;
  105.   
  106.   if (!node)
  107.     return VNULL;
  108.   
  109.   switch_to_segment (str_seg);
  110.   Dn_old = V_PTR (node->Dn.off, TRNode);
  111.   Rh_old = V_PTR (node->Rh.off, TRNode);
  112.   if (node->code == COLUMN)
  113.     V_ptr = node->Ptr.off;
  114.   else
  115.     if (node->Ptr.off)
  116.       {
  117. du = V_PTR (node->Ptr.off, DataUnit);
  118. dat = &(du->dat);
  119. if (du->type.code == T_STR)
  120.   str_dat = V_PTR (STR_VPTR (dat), char);
  121.       }
  122.   
  123.   switch_to_segment (cur_seg);
  124.   V_Dn = load_tree (Dn_old, cur_seg, str_seg);
  125.   V_Rh = load_tree (Rh_old, cur_seg, str_seg);
  126.   if (du)
  127.     {
  128.       V_ptr = VMALLOC (1, DataUnit);
  129.       *V_PTR (V_ptr, DataUnit) = *du;
  130.       if (str_dat)
  131. {
  132.   i4_t len = strlen (str_dat);
  133.   char *str_ptr;
  134.   VADR V_str_ptr;
  135.   
  136.   P_VMALLOC (str_ptr, len + 1, char);
  137.   bcopy (str_dat, str_ptr, len + 1);
  138.   STR_VPTR (&(V_PTR (V_ptr, DataUnit)->dat)) = V_str_ptr;
  139. }
  140.     }
  141.   
  142.   P_VMALLOC (res_node, 1, TRNode);
  143.   *res_node = *node;
  144.   res_node->Dn.off = V_Dn;
  145.   res_node->Rh.off = V_Rh;
  146.   res_node->Ptr.off = V_ptr;
  147.     
  148.   return V_res_node;
  149. } /* load_tree */
  151. int
  152. res_row_save (char *nl_arr, i4_t nr, DataUnit **colval)
  153. {
  154.   char *pointbuf, *ptr, nl_fl;
  155.   i4_t i, err;
  156.   DataUnit *to;
  157.   i2_t len;
  158.   
  159.   pointbuf = nl_arr + nr;
  160.   for (i = 0; i < nr; i++)
  161.     {
  162.       to = colval[i];
  163.       len = 0;
  164.       ptr = NULL;
  165.       nl_fl = (nl_arr[i]) ? REGULAR_VALUE : NULL_VALUE;
  166.       
  167.       if (nl_fl == REGULAR_VALUE)
  168. {
  169.   len = t2bunpack (pointbuf);
  170.   if (len < 0)
  171.     return -ER_BUF;
  172.   pointbuf += sizeof(u2_t);
  173.   ptr = pointbuf;
  174.   pointbuf += len;
  175. }
  176.       
  177.       err = mem_to_DU (nl_fl, to->type.code, len, ptr, to);
  178.       if (err < 0)
  179. return err;
  180.     }
  181.   return 0;
  182. } /* res_row_save */
  185. int
  186. DU_to_buf (DataUnit *dt_from, char **pointbuf, sql_type_t *to_type)
  187.      /* returns 0 if O'K and < 0 if error */
  188.      /* if to_type == NULL => type from dt_from won't be changed */
  189. {
  190.   TpSet Place;
  191.   i4_t len, err;
  192.   
  193.   if (dt_from->type.code == T_STR)
  194.     {
  195.       t2bto2char (len = dt_from->type.len, *pointbuf);
  196.       *pointbuf += SZ_SHT;
  197.       memcpy (*pointbuf, STR_PTR (&(dt_from->dat)), len);
  198.       *pointbuf += len;
  199.     }
  200.   else
  201.     {
  202.       len = sizeof_sqltype (*to_type);
  203.       t2bto2char (len, *pointbuf);
  204.       *pointbuf += SZ_SHT;
  205.       err = put_dat (&(dt_from->dat), 0, dt_from->type.code,
  206.      REGULAR_VALUE, &Place, 0,
  207.      (to_type) ? to_type->code : dt_from->type.code, NULL);
  208.       if (err < 0)
  209. return err;
  210.       memcpy (*pointbuf, (char *) (&Place), len);
  211.       *pointbuf += len;
  212.     }
  213.   return 0;
  214. } /* DU_to_buf */
  216. int
  217. DU_to_rpc (DataUnit *dt_from, parm_t *to, i4_t typ)
  218. {
  219.   char null_fl;
  220.   i4_t err = 0;
  221.   
  222.   assert (dt_from && to);
  223.   null_fl= dt_from->dat.nl_fl;
  224.   
  225.   to->value.type = typ;
  226.   to->indicator = (null_fl == NULL_VALUE) ? -1 : 0;
  227.   if (null_fl == REGULAR_VALUE)
  228.     if (typ == T_STR)
  229.       {
  230. to->value.data_u.Str.Str_val = STR_PTR (&(dt_from->dat));
  231. to->value.data_u.Str.Str_len = dt_from->type.len;
  232.       }
  233.     else
  234.       err = put_dat (&VL(&(dt_from->dat)), 0, dt_from->type.code, 
  235.      REGULAR_VALUE, &(to->value.data_u), 0, typ, NULL);
  236.   return err;
  237. } /* DU_to_rpc */
  239. void
  240. conv_DU_to_str (DataUnit *from, DataUnit *to)
  241. {
  242.   sql_type_t *typ_to, *typ_from;
  243.   TpSet *dat_to, *dat_from;
  244.   
  245.   *to = *from;
  246.   dat_from = &(from->dat);
  247.   typ_from = &(from->type);
  248.   dat_to   = &(to->dat);
  249.   typ_to   = &(to->type);
  250.   if (NL_FL (dat_from) == REGULAR_VALUE && typ_from->code != T_STR)
  251.     {
  252.       typ_to->code = T_STR;
  253.       typ_to->len = sizeof_sqltype (*typ_from);
  254.       STR_PTR (dat_to) = (char *) (&VL (dat_from));
  255.     }
  256.   MAX_LEN (dat_to) = 0;
  257. } /* conv_DU_to_str */
  260. int
  261. mem_to_DU (char nl_fl, byte typ_from_code,
  262.    i2_t from_len, void *from, DataUnit *to)
  263. /* This function returns value:                         *
  264.  * 0   - if it's all right,                             *
  265.  * < 0 - if error,                                      *
  266.  * > 0 - if argument is string and this value = lenght  *
  267.  *       of this string. It is greater than res_size    *
  268.  *       (so string was shortened).                     *
  269.  * NOTE : if from_len < 0 & argument is string =>       *
  270.  *        its lenght is evaluated as strlen (from)      */
  271. {
  272.   i4_t err = 0, len;
  273.   sql_type_t *typ_to;
  274.   TpSet *dat_to;
  275.   
  276.   typ_to = &(to->type);
  277.   dat_to = &(to->dat);
  278.   
  279.   NL_FL (dat_to) = nl_fl;
  280.   if (nl_fl == REGULAR_VALUE)
  281.     {
  282.       if (typ_from_code == T_STR)
  283. {
  284.   if (from_len < 0)
  285.     from_len = strlen ((char *)from);
  286.   CHECK_ARR_SIZE (STR_PTR (dat_to), MAX_LEN (dat_to), from_len+1, char);
  287.   len = typ_to->len = from_len;
  288.   STR_PTR (dat_to)[from_len] = 0; /* null-terminating of the string for *
  289.    * functions from catfun.c            */
  290. }
  291.       else
  292. {
  293.   len = sizeof_sqltype (*typ_to);
  294.   if (MAX_LEN (dat_to))
  295.     {
  296.       xfree (STR_PTR (dat_to));
  297.       MAX_LEN (dat_to) = 0;
  298.     }
  299. }
  300.       if (typ_from_code == typ_to->code)
  301. bcopy ((char *) from, DU_PTR_VL (*to), len);
  302.       else if (typ_from_code == T_STR)
  303.         err = -ER_1;
  304.       else
  305.         {
  306.           TpSet tmp;
  307.           sql_type_t type_tmp = pack_type(typ_from_code, 0, 0);
  308.           
  309.           bcopy ((char *) from, (char *)(&tmp), sizeof_sqltype (type_tmp));
  310.           err = put_dat (&tmp, from_len, typ_from_code, REGULAR_VALUE,
  311.                          DU_PTR_VL (*to), typ_to->len, typ_to->code, NULL);
  312.         }
  313.     }
  314.   return err;
  315. } /* rpc_to_mem */
  316.   
  317. int
  318. rpc_to_DU (parm_t *from, DataUnit *to)
  319. /* This function returns value:                         *
  320.  * 0   - if it's all right,                             *
  321.  * < 0 - if error,                                      *
  322.  * > 0 - if argument is string and this value = lenght  *
  323.  *       of this string. It is greater than res_size    *
  324.  *       (so string was shortened).                     */
  325. {
  326.   byte typ_from_code;
  327.   
  328.   typ_from_code = from->value.type;
  329.   return mem_to_DU ((from->indicator < 0) ? NULL_VALUE : REGULAR_VALUE,
  330.     typ_from_code,
  331.     (typ_from_code == T_STR) ?
  332.     from->value.data_u.Str.Str_len : 0,
  333.     (typ_from_code == T_STR) ?
  334.     from->value.data_u.Str.Str_val :
  335.            (void *)(&(from->value.data_u)), to);
  336. } /* rpc_to_DU */
  338. int
  339. PutDataNext (TRNode * cur)
  340. {
  341.   DtPush;
  342.   switch (cur->code)
  343.     {
  344.     case USERNAME :
  345.       NlFlCur = REGULAR_VALUE;
  346.       StrCur = current_user_login_name;
  347.       CodCur = T_STR;
  348.       LenCur = strlen(current_user_login_name);
  349.       break;
  350.       
  351.     case EXISTS   :
  352.       NlFlCur = REGULAR_VALUE;
  353.       LngCur = TRUE; /* result of SubQuery is already calculated */
  354.       CodCur = T_BOOL;
  355.       LenCur = 0;
  356.       
  357.       /* saving of SubQuery result : */
  358.       LngPred = TRUE;
  359.       break;
  360.       
  361.     case COLUMN :
  362.       /* column pointer in tree from CHECK constraint */
  363.       assert(ins_col_values!=NULL);
  364.       DtCurEl = ins_col_values[(i4_t)(cur->Ptr.off)];
  365.       break;
  366.       
  367.     default     :
  368.       DtCurEl = *TP_ADR (cur, Ptr, DataUnit);
  369.       CHECK_FLAG (DtCurEl);
  370.       if (NlFlCur == UNKNOWN_VALUE)
  371. return -ER_1;
  372.       break;
  373.     } /* switch */
  374.   return 0;
  375. } /* PutDataNext */
  377. #define OPERATION(simb) switch (m1) {                          
  378.         case T_SRT : SrtPred = SRT_VL (pt1) simb SRT_VL (pt2); 
  379.                      break;                                    
  380.         case T_INT : IntPred = INT_VL (pt1) simb INT_VL (pt2); 
  381.                      break;                                    
  382.         case T_LNG : LngPred = LNG_VL (pt1) simb LNG_VL (pt2); 
  383.                      break;                                    
  384.         case T_FLT : FltPred = FLT_VL (pt1) simb FLT_VL (pt2); 
  385.                      break;                                    
  386.         case T_DBL : DblPred = DBL_VL (pt1) simb DBL_VL (pt2); 
  387.                      break;                                    
  388.         default    : return(-ER_1);       /* ERROR */          
  389.       } /* switch */                                           
  390.       break
  391.       
  392. #define RET(err) { DtPop;        
  393.                    return err; }
  395. int
  396. oper (byte code, i4_t arity)
  397. /* Operation "code" making. Two highest stack elements are * 
  398.  * arguments. It both are being deleted and result of this *
  399.  * operation is being put into head of stack               */
  400. {
  401.   byte m1, m2;
  402.   TpSet *pt1, *pt2, dop;
  403.   i2_t size;
  404.   i4_t err, m, cod1 = 0, cod2 = 0;
  405.   char cod_res;
  406.   
  407.   /* next table is used for calculation of the result       *
  408.    * of AND & OR operations : 0 - NULL, 1 - FALSE, 2 - TRUE */
  409.   
  410.   char OR_AND_tbl[2][3][3] = { /* NULL   FALSE   TRUE */
  411.     /* AND : */
  412.            /* NULL  */ { { 0,      1,      0 },
  413.                    /* FALSE */   { 1,      1,      1 },
  414.    /* TRUE  */   { 0,      1,      2 } },
  415.   
  416.     /* OR  : */                         
  417.                    /* NULL  */ { { 0,      0,      2 },
  418.                    /* FALSE */   { 0,      1,      2 },
  419.            /* TRUE  */   { 2,      2,      2 } }
  420.   };
  421.   
  422. #define U_MINUS(type, val) case type: val = - val; break;
  424.   if (arity == 1) /* unary operation */
  425.     {
  426.       if (Is_SQPredicate_Code (code))
  427. {
  428.   i4_t res = FALSE;
  429.       
  430.     if (code == SUBQUERY) /* in comparison predicate */
  431.     if (NlFlPred == UNKNOWN_VALUE)
  432.       DtPredEl = DtCurEl; 
  433.     else /* second row in SubQuery result */
  434.       return -ER_SQ;
  435.   
  436.   else /* ALL | SOME */
  437.     {
  438.       if (NlFlCur == NULL_VALUE)
  439. NlFlPred = NULL_VALUE;
  440.       else
  441. if (((code == ALL)  && !LngCur) ||
  442.     ((code == SOME) && LngCur))
  443.   {
  444.     NlFlPred = REGULAR_VALUE;
  445.     LngPred = LngCur;
  446.     res = TRUE; /* exit from SubQuery handling */
  447.   }
  448.     }
  449.   NlFlCur = REGULAR_VALUE;
  450.   LngCur = res;
  451.   CodCur = T_BOOL;
  452.   LenCur = 0;
  453. }
  454.       else
  455. switch (code)
  456.   {
  457.   case UMINUS :
  458.     switch (CodCur)
  459.       {
  460. U_MINUS (T_SRT, SrtCur);
  461. U_MINUS (T_INT, IntCur);
  462. U_MINUS (T_LNG, LngCur);
  463. U_MINUS (T_FLT, FltCur);
  464. U_MINUS (T_DBL, DblCur);
  465.       default:
  466. return (-ER_1);
  467.       }
  468.     break;
  469.     
  470.   case NOT :
  471.     if (NlFlCur == REGULAR_VALUE)
  472.       LngCur = ! LngCur ;
  473.     break;
  474.   
  475.   case ISNULL :
  476.     LngCur = (NlFlCur == NULL_VALUE);
  477.     CodCur = T_BOOL;
  478.     NlFlCur = REGULAR_VALUE;
  479.     break;
  480.   
  481.   case ISNOTNULL :
  482.     LngCur = (NlFlCur == REGULAR_VALUE);
  483.     CodCur = T_BOOL;
  484.     NlFlCur = REGULAR_VALUE;
  485.     break;
  486.   
  487.   case NOOP :
  488.     break;
  489.     
  490.   default:
  491.     return (-ER_3); /* ERROR */
  492.   }
  493.       return 0;
  494.     }
  495.   
  496. #undef U_MINUS
  497.   
  498.   /* other operations are binary */
  499.   
  500.   if ((code == OR) || (code == AND))
  501.     {
  502.       if (NlFlPred == REGULAR_VALUE)
  503. cod1 = LngPred + 1; 
  504.       if (NlFlCur == REGULAR_VALUE)
  505. cod2 = LngCur + 1; 
  506.       cod_res = OR_AND_tbl[code == OR][cod1][cod2];
  507.       
  508.       if (cod_res)
  509. {
  510.   NlFlPred = REGULAR_VALUE;
  511.   LngPred = cod_res - 1;
  512.   CodPred = T_BOOL;
  513. }
  514.       
  515.       else
  516. NlFlPred = NULL_VALUE;
  517.       
  518.       RET (0);
  519.     }
  521.   if ((NlFlPred != REGULAR_VALUE) ||
  522.       (NlFlCur != REGULAR_VALUE))
  523.     {
  524.       NlFlPred = NULL_VALUE;
  525.       RET (0);
  526.     }
  527.   
  528.   NlFlPred = REGULAR_VALUE;
  529.   if (CodPred == T_STR)
  530.     { /* string */
  531.       /* There are only binary comparison operations for strings. *
  532.        * Strings aren't in any other operations.                  */
  534.       size = (LenPred > LenCur) ? LenPred : LenCur;
  535.       m = strncmp (StrPred, StrCur, size);
  536.       LngPred = 0;
  537.       switch (code)
  538. {
  539. case EQU:
  540.   if (m == 0)
  541.     LngPred = 1;
  542.   break;
  543. case NE:
  544.   if (m != 0)
  545.     LngPred = 1;
  546.   break;
  547. case GT:
  548.   if (m > 0)
  549.     LngPred = 1;
  550.   break;
  551. case LT:
  552.   if (m < 0)
  553.     LngPred = 1;
  554.   break;
  555. case GE:
  556.   if (m >= 0)
  557.     LngPred = 1;
  558.   break;
  559. case LE:
  560.   if (m <= 0)
  561.     LngPred = 1;
  562.   break;
  563. default:
  564.   RET (-ER_3);
  565. } /* switch */
  567.       CodPred = T_BOOL;
  568.     }
  569.   else
  570.     { /* operation between numbers */
  571.       m1 = CodPred;
  572.       pt1 = &DatPred;
  573.       m2 = CodCur;
  574.       pt2 = &DatCur;
  575.       if (m1 > m2)
  576. {
  577.   pt2 = &dop;
  578.   err = put_dat (&DatCur, 0, m2, REGULAR_VALUE, pt2, 0, m1, NULL);
  579.   if (err)
  580.     RET (err);
  581. }
  582.       if (m1 < m2)
  583. {
  584.   pt1 = &dop;
  585.   err = put_dat (&DatPred, 0, m1, REGULAR_VALUE, pt1, 0, m2, NULL);
  586.   if (err)
  587.     RET (err);
  588.           m1 = m2;
  589. }
  590.       CodPred = m1;
  591.       /* type of the result is in ResCode now */
  592.       switch (code)
  593. {
  594. case ADD:  OPERATION (+);
  595. case SUB:  OPERATION (-);
  596. case DIV:  OPERATION (/);
  597. case MULT: OPERATION (*);
  598. case NE:   OPERATION (!=);
  599. case EQU:  OPERATION (==);
  600. case GT:   OPERATION (>);
  601. case LT:   OPERATION (<);
  602. case GE:   OPERATION (>=);
  603. case LE:   OPERATION (<=);
  604. default:
  605.   RET (-ER_3);
  606.   /* . . . */
  608. } /* switch */
  609.     } /* if else */
  610.   RET (0);
  611. } /* "oper" */
  613. float
  614. sel_const (i4_t op, DataUnit *cnst, DataUnit *min, DataUnit *max)
  615.      /* makes estimation of selectivity for simple predicate  *
  616.       * of type : col_name 'op' cnst;                        *
  617.       * min & max - statistic about column col_name           *
  618.       * function assumes that cnst, min, max are all REGULAR */
  619. {
  620.   float sel = 0.0;
  621.   int error;
  622. #define pow_256(pow) (0x1000000 >> (8*pow))
  623.   
  624.   if (op == EQU)
  625.     return sel;
  626.   
  627.   CHECK_FLAG (*cnst); 
  628.   assert (cnst->dat.nl_fl == REGULAR_VALUE);
  629.   MK_BIN_OPER (GT, *cnst, *min);
  630.   if (COMP_RESULT)
  631.     /* cnst > min */
  632.     {
  633.       MK_BIN_OPER (LT, *cnst, *max);
  634.       if (COMP_RESULT)
  635. /* cnst < max */
  636. {
  637.   if (cnst->type.code == T_STR)
  638.     {
  639.       u4_t min_long = 0, max_long = 0, cnst_long = 0;
  640.       i4_t min_str_lng, i, j;
  641.       i4_t len_min = min->type.len;
  642.       i4_t len_max = max->type.len;
  643.       i4_t len_cnst = cnst->type.len;
  644.       char *str_min = STR_PTR (&(min->dat));
  645.       char *str_max = STR_PTR (&(max->dat));
  646.       char *str_cnst = STR_PTR (&(cnst->dat));
  647.     
  648.       min_str_lng = (len_min < len_max) ? len_min : len_max;
  649.       min_str_lng = (min_str_lng < len_cnst) ? min_str_lng : len_cnst;
  650.       for (i = 0; i < min_str_lng; i++)
  651. if (str_min[i] != str_cnst[i] || str_max[i] != str_cnst[i])
  652.   break;
  653.     
  654.       for (j = 0; j < SZ_LNG && i+j < len_min; j++)
  655. min_long += ((u4_t) (str_min[i+j])) * pow_256(j);
  656.       for (j = 0; j < SZ_LNG && i+j < len_max; j++)
  657. max_long += ((u4_t) (str_max[i+j])) * pow_256(j);
  658.       for (j = 0; j < SZ_LNG && i+j < len_cnst; j++)
  659. cnst_long += ((u4_t) (str_cnst[i+j])) * pow_256(j);
  660.       assert (min_long != max_long);
  661.     
  662.       sel = ((float)cnst_long - (float)min_long) /
  663. ((float)max_long - (float)min_long);
  664.     }
  665.   else
  666.     {
  667.       DataUnit  cnst_sub_min, max_sub_min;
  668.     
  669.       MK_BIN_OPER (SUB, *max, *min);
  670.       max_sub_min = OPER_RESULT;
  671.       MK_BIN_OPER (SUB, *cnst, *min);
  672.       cnst_sub_min = OPER_RESULT;
  673.     
  674.       /* changing both subtraction results to float */
  675.       error = put_dat (&(cnst_sub_min.dat), 0, cnst_sub_min.type.code,
  676.        REGULAR_VALUE, &(cnst_sub_min.dat), 0, T_FLT, NULL);
  677.       if (error < 0)
  678. return error;
  679.       cnst_sub_min.type.code = T_FLT;
  680.       error = put_dat (&(max_sub_min.dat), 0, max_sub_min.type.code,
  681.        REGULAR_VALUE, &(max_sub_min.dat), 0, T_FLT, NULL);
  682.       if (error < 0)
  683. return error;
  684.       max_sub_min.type.code = T_FLT;
  685.     
  686.       MK_BIN_OPER (DIV, cnst_sub_min, max_sub_min);
  687.       sel = FLT_VL (&(OPER_RESULT.dat));
  688.     }
  689.   if (op == GT || op == GE)
  690.     sel = 1.0 - sel;
  691. }
  692.       else /* cnst >= max */
  693. if (op == LT || op == LE)
  694.   sel = 1.0;
  695.     }
  696.   else/* cnst <= min */
  697.     if (op == GT || op == GE)
  698.       sel = 1.0;
  699.   
  700.   return sel;
  701. } /* sel_const */
  703. /* translate data type in compiler to data type in BD */
  704. void
  705. type_to_bd (sql_type_t *tp_from, sql_type_t *tp_to)
  706. {
  707.   tp_to->len = sizeof_sqltype (*tp_from);
  708.   
  709.   switch (tp_from->code)
  710.     {
  711.     case T_STR:
  712.       tp_to->code = TCH;
  713.       break;
  714.     case T_SRT:
  715.       tp_to->code = T2B;
  716.       break;
  717.     case T_INT:
  718.       tp_to->code = T4B;
  719.       break;
  720.     case T_LNG:
  721.       tp_to->code = T4B;
  722.       break;
  723.     case T_FLT:
  724.     case T_DBL:
  725.       tp_to->code = TFLOAT;
  726.       break;
  727.     }
  728. }
  730. #define PR_CONST(typ_field,trn_func)                        
  731.   typ_field (dat_to) = trn_func (STRING (CNST_NAME (ptr))); 
  732.   break
  734. void
  735. prepare_CONST (TXTREF ptr, VADR V_PTN)
  736. /* this function prepares constant value for plan generator; it   *
  737.  * means that in the place befor constant value function locates  *
  738.  * flag(char) defining whether it's undefined or undeclared or    *
  739.  * regular value; returns pointer to value itself                 */
  740. {
  741.   VADR V_str;
  742.   char *str;
  743.   DataUnit *hole;
  744.   VADR V_hole;
  745.   TpSet *dat_to;
  746.   TRNode *PTN;
  747.   
  748.   P_VMALLOC (hole, 1, DataUnit);
  749.   dat_to = &(hole->dat);
  750.   PTN = V_PTR (V_PTN, TRNode);
  751.   hole->type = PTN->Ty = CNST_STYPE (ptr);
  752.   
  753.   PTN->code = CONST;
  754.   PTN->Ptr.off = V_hole;
  755.   
  756.   if (CODE_TRN (ptr) == NULL_VL)
  757.     {
  758.       NL_FL (dat_to) = NULL_VALUE;
  759.       return;
  760.     }
  761.   
  762.   assert (CODE_TRN (ptr) == CONST);
  763.   NL_FL (dat_to) = REGULAR_VALUE;
  764.   
  765.   switch (CNST_STYPE (ptr).code)
  766.     {
  767.     case SQLType_Short:
  768.       PR_CONST (SRT_VL, atol);
  769.     case SQLType_Int:
  770.       PR_CONST (INT_VL, atol);
  771.     case SQLType_Long:
  772.       PR_CONST (LNG_VL, atol);
  773.     case SQLType_Float:
  774.     case SQLType_Real:
  775.       PR_CONST (FLT_VL, atof);
  776.     case SQLType_Double:
  777.       PR_CONST (DBL_VL, atof);
  778.     case SQLType_Char:
  779.       {
  780. i4_t len = strlen (STRING (CNST_NAME (ptr)));
  782. hole->type.len = PTN->Ty.len = len;
  783. P_VMALLOC (str, len+1, char);
  784. bcopy (STRING (CNST_NAME (ptr)), str, len);
  785.         str[len]=0;
  786. STR_VPTR (dat_to) = V_str;
  787. NL_FL (dat_to) = NOT_CONVERTED;
  788.       }
  789.       break;
  790.     default:
  791.       yyfatal (" Unknown type in constant preparation n");
  792.     }
  793. }
  795. #undef PR_CONST
  797. void
  798. prepare_USERNAME (TRNode *PTN)
  799. {
  800.   PTN->code = USERNAME;
  801.   PTN->Ty.code = T_STR;
  802.   PTN->Ty.len = US_NAME_LNG;
  803. }
  805. VADR
  806. prepare_HOLE (sql_type_t typ)
  807. /* preparation of hole in module for data of this type */
  808. {
  809.   DataUnit *hole;
  810.   VADR V_hole;
  811.   
  812.   P_VMALLOC (hole, 1, DataUnit);
  813.   hole->type = typ;
  814.   return V_hole;
  815. } /* prepare_HOLE */