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

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

SQL Server

开发平台：

Unix_Linux

sql_type.c：源码内容
  1. /*
  2.  *  sql_type.c  - SQL types support library for SQL precompiler
  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 Prpgramming
  8.  *  This file is written by Michael Kimelman & 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: sql_type.c,v 1.246 1997/03/31 11:03:16 kml Exp $ */
  30. #include "setup_os.h"
  31. #include "sql.h"
  32. #include "global.h"
  33. #include "type_lib.h"
  34. #include <assert.h>
  36. /*******==================================================*******
  37. *******            Type conversion functions               *******
  38. *******==================================================*******/
  39. static struct
  40. {
  41.   char                *SQLtypename;
  42.   dyn_sql_type_code_t  dyn_id;
  43. } typesname[]= {
  45. #define DEF_SQLTYPE(Code,SQLstr,Cstr,Dyn_Id)    {SQLstr,Dyn_Id},
  46. #include "sql_type.def"
  47.   { NULL, 0 }
  48. };
  50. /*******==================================================*******
  51. *******            Type conversion functions               *******
  52. *******==================================================*******/
  54. void 
  55. conv_type (char *s, sql_type_t * l, i4_t direct)  /* direct=s->l?1:0 */
  56. {
  57.   sql_type_t tt;
  58.   byte ll = 0;
  59.   char c, c1;
  60.   i4_t len, prec;
  61.   char buffer[20];
  62.   assert (s != NULL);
  63.   assert (l != NULL);
  64.   if (direct)
  65.     {
  66.       sscanf (s, "%[^[]%*c%u%c%u%c", buffer, &len, &c, &prec, &c1);
  67.       tt.len = (i2_t) len;
  68.       tt.prec = (byte) (prec & 0xff);
  69.       if (c != ',' || c1 != ']')
  70. {
  71.   fprintf (stderr, "Internal error at %s:%d: "
  72.    "incorrect type format in string '%s'n",
  73.    __FILE__, __LINE__, s);
  74.   return;
  75. }
  76.       ll = (byte) SQLType_LAST;
  77.       while (ll--)
  78. if (0 == strcmp (buffer, typesname[ll].SQLtypename))
  79.   {
  80.     tt.code = ll;
  81.     break;
  82.   }
  83.       *l = tt;
  84.       conv_type (buffer, l, 0); /* restore string */
  85.       if (strncmp (buffer, s,strlen(buffer)))
  86. yyfatal ("Trl.conv_type: Internal error in algorithm");
  87.     }
  88.   else
  89.     {
  90.       tt = *l;
  91.       sprintf (s, "%s[%u,%u]", typesname[tt.code].SQLtypename,
  92.        (int) tt.len, (int) tt.prec);
  93.     }
  94. }
  96. dyn_sql_type_code_t
  97. get_dyn_sqltype_code(SQLType t)
  98. {
  99.   if (t<=SQLType_0 || t>=SQLType_LAST)
  100.     return 0;
  101.   return typesname[t].dyn_id;
  102. }
  104. SQLType
  105. get_sqltype_code(dyn_sql_type_code_t t)
  106. {
  107.   SQLType i;
  108.   for(i=0;i<SQLType_LAST;i++)
  109.     if(typesname[i].dyn_id ==t)
  110.       return i;
  111.   return SQLType_0;
  112. }
  114. sql_type_t 
  115. pack_type (SQLType tpname, i2_t lenght, i2_t prec)
  116. {
  117. #define LEN1(tl)   (i4_t)(tl*2.4+0.99)
  118. #define LEN(t)     LEN1((sizeof(t)))
  119. #define FATAL(str)   fprintf(STDERR,"%sn",str)
  120.   sql_type_t tt;
  121.   
  122.   assert (tpname < SQLType_LAST);
  123.   if (prec > 0xff)
  124.     {
  125.       char s[100];
  126.       sprintf(s,"trl.pack_type: precision (%d) more than 256",prec);
  127.       FATAL (s);
  128.       prec = 0xff;
  129.     }
  130.   assert ( (prec & 0xff) == prec );
  131.   
  132.   tt.prec = prec;
  133.   tt.code = tpname;
  134.   tt.len = lenght;
  135.   
  136.   if ( prec > lenght )
  137.     {
  138.       char s[100];
  139.       sprintf(s,"trl.pack_type: precision more than lenght in '%s'",
  140.       type2str(tt));
  141.       FATAL (s);
  142.       prec = lenght - 1;
  143.     }
  144.   switch (tt.code)
  145.     {
  146.     case SQLType_0:
  147.       tt.len  = 0;
  148.       tt.prec = 0;
  149.       break;
  150.     case SQLType_Char:
  151.     case SQLType_CharVar:
  152.       tt.prec = 0;
  153.       tt.code = SQLType_Char;
  154.       break;
  155.     case SQLType_Short:
  156.       tt.len = LEN (i2_t);
  157.       tt.prec = 0;
  158.       break;
  159.     case SQLType_Int:
  160.       tt.len = LEN (i4_t);
  161.       tt.prec = 0;
  162.       break;
  163.     case SQLType_Long:
  164.       tt.len = LEN (i4_t);
  165.       tt.prec = 0;
  166.       break;
  167.     case SQLType_Real:
  168.       tt.len = LEN1 (3);
  169.       tt.prec = 0;
  170.       break;
  171.     case SQLType_Double:
  172.       tt.len = LEN1 (6);
  173.       tt.prec = 0;
  174.       break;
  175.     case SQLType_Num:
  176.       if ( tt.prec == 0 )
  177. {
  178.   if (tt.len <= LEN (i2_t) )
  179.     {
  180.       tt.code = SQLType_Short;
  181.       tt.len  = LEN (i2_t);
  182.       break;
  183.     }
  184.   else if (tt.len <= LEN (i4_t) )
  185.     {
  186.       tt.code = SQLType_Long;
  187.       tt.len  = LEN (i4_t);
  188.       break;
  189.     }
  190. }
  191.     case SQLType_Float:
  192.       tt.prec = 0;
  193.       if (tt.len <= LEN1(3) )
  194. {
  195.   tt.code = SQLType_Real;
  196.   tt.len  = LEN1(3);
  197.   break;
  198. }
  199.       else if (tt.len <= LEN1(6) )
  200. {
  201.   tt.code = SQLType_Double;
  202.   tt.len  = LEN1(6);
  203.   break;
  204. }
  205.     default:
  206.       /* error should be detected here */
  207.       FATAL("sql_type.pack_type: unacceptable type given ");
  208.       fprintf(STDERR,"-%s ",type2str(tt));
  209.       tt.code = SQLType_Double;
  210.       tt.len  = LEN1(6);
  211.       fprintf(STDERR,"--> %s n",type2str(tt));
  212.     }
  213.   return tt;
  214. #undef FATAL
  215. #undef LEN
  216. #undef LEN1
  217. }
  219. sql_type_t 
  220. read_type (char *s)
  221. {
  222.   sql_type_t t;
  223.   conv_type (s, &t, 1);
  224.   return t;
  225. }
  227. char *
  228. type2str (sql_type_t t)
  229. {
  230.   static char b[40];
  231.   sql_type_t t2 = t;
  232.   conv_type (b, &t2, 0);
  233.   return b;
  234. }
  236. i4_t
  237. type2long (sql_type_t t)
  238. {
  239.   return *(i4_t*)&t;
  240. }
  242. i4_t
  243. user_to_rpc (gsql_parm *parm, parm_t *rpc_arg)
  244. {
  245.   char *str;
  246.   
  247.   rpc_arg->value.type = parm->type;
  248.   rpc_arg->indicator = (parm->indptr) ? *(parm->indptr) : 0;
  249.   switch (parm->type)
  250.     {
  251.     case T_STR /* SQLType_Char */ :
  252.       str = *(char **)(parm->valptr);
  253.       rpc_arg->value.data_u.Str.Str_len = strlen (str);
  254.       rpc_arg->value.data_u.Str.Str_val = str;
  255.       break;
  256.     case SQLType_Short:
  257.       rpc_arg->value.data_u.Shrt = *((i2_t *)(parm->valptr));
  258.       break;
  259.     case SQLType_Int :
  260.       rpc_arg->value.data_u.Int  = *((i4_t *)(parm->valptr));
  261.       break;
  262.     case SQLType_Long :
  263.       rpc_arg->value.data_u.Lng  = *((i4_t *)(parm->valptr));
  264.       break;
  265.     case SQLType_Real :
  266.       rpc_arg->value.data_u.Flt  = *((float *)(parm->valptr));
  267.       break;
  268.     case SQLType_Double :
  269.       rpc_arg->value.data_u.Dbl  = *((double *)(parm->valptr));
  270.       break;
  271.     default    :
  272.       return -ER_CLNT;
  273.     }
  274.   return 0;
  275. } /* user_to_rpc */
  277. i4_t
  278. rpc_to_user (parm_t *rpc_res, gsql_parm *parm)
  279. {
  280.   i4_t typ, error = 0, size, from_size, to_size;
  281.   
  282.   if (rpc_res->indicator != -1) /* current result is REGULAR_VALUE */
  283.     {
  284.       if (parm->indptr)
  285. *(parm->indptr) = rpc_res->indicator;
  287.       typ = parm->type;
  288.       if (typ == T_STR)
  289. {
  290.   from_size = rpc_res->value.data_u.Str.Str_len;
  291.   to_size = parm->length - 1;
  292.   size = (to_size > from_size) ? from_size : to_size;
  293.   bcopy (rpc_res->value.data_u.Str.Str_val,
  294.  (char *) (parm->valptr), size);
  295.   ((char *) (parm->valptr))[size] = '';
  296. }
  297.       else
  298. error = put_dat (&(rpc_res->value.data_u), 0, rpc_res->value.type,
  299.  REGULAR_VALUE, parm->valptr, 0, typ, NULL);
  301.       if (error > 0) /* res_dt-string was shortened */
  302. if (parm->indptr)
  303.   *(parm->indptr) = error;
  304.   
  305.       if (error < 0)
  306. return error;
  307.     }
  308.   else
  309.     /* current result is NULL_VALUE */
  310.     if (parm->indptr)
  311.       *(parm->indptr) = -1;
  312.     else
  313.       return -ND_INDIC;
  314.   
  315.   return 0;
  316. } /* rpc_to_user */
  318. i4_t 
  319. put_dat (void *from, i4_t from_size, byte from_mask, char from_nl_fl,
  320.  void *to,   i4_t to_size_,  byte to_mask_,  char *to_nl_fl)
  322. /* Copying of information accordingly "*_mask"          *
  323.  * (if to_mask_==0 => type isn't being changed).        *
  324.  * This function returns value:                         *
  325.  * 0 - if it's all right,                               *
  326.  * < 0 - if error,                                      *
  327.  * > 0 - if result is string and this value = lenght of *
  328.  *       this string. It is greater than res_size       *
  329.  *       (so string was shortened).                     */
  330. {
  331.   i2_t size;
  332.   byte to_mask = (to_mask_) ? to_mask_ : from_mask;
  333.   i4_t to_size = (to_size_) ? to_size_ : from_size;
  334.   
  335.   if (to_nl_fl)
  336.     *to_nl_fl = from_nl_fl;
  337.   
  338.   if (from_nl_fl != REGULAR_VALUE)
  339.     return 0;
  340.   
  341.   if (from_mask == T_STR)
  342.     {
  343.       size = (to_size > from_size) ? from_size : to_size;
  344.       if (to_mask != T_STR)
  345. return (-ER_1);
  346.       bcopy ((char *) from, (char *) to, size);
  347.       return from_size - size;
  348.     }
  349.   
  350.   /* trere are handled here numbers only */
  351.   if (from_mask == to_mask)
  352.     switch (from_mask)
  353.       {
  354.       case T_SRT:
  355. *(i2_t *) to = *(i2_t *) from;
  356. break;
  357.       case T_INT:
  358. *(i4_t *) to = *(i4_t *) from;
  359. break;
  360.       case T_LNG:
  361. *(i4_t *) to = *(i4_t *) from;
  362. break;
  363.       case T_FLT:
  364. *(float *) to = *(float *) from;
  365. break;
  366.       case T_DBL:
  367. *(double *) to = *(double *) from;
  368. break;
  369.       default:
  370. return (-ER_1); /* ERROR */
  371.       } /* switch */
  372.   else
  373.     switch (to_mask)
  374.       {
  376.       case T_SRT:
  377. switch (from_mask)
  378.   {
  379.   case T_INT:
  380.     *(i2_t *) to = (i2_t) (*(i4_t *) from);
  381.     break;
  382.   case T_LNG:
  383.     *(i2_t *) to = (i2_t) (*(i4_t *) from);
  384.     break;
  385.   case T_FLT:
  386.     *(i2_t *) to = (i2_t) (*(float *) from);
  387.     break;
  388.   case T_DBL:
  389.     *(i2_t *) to = (i2_t) (*(double *) from);
  390.     break;
  391.   default:
  392.     return (-ER_1); /* ERROR */
  393.   } /* switch */
  394. break;
  396.       case T_INT:
  397. switch (from_mask)
  398.   {
  399.   case T_SRT:
  400.     *(i4_t *) to = (i4_t) (*(i2_t *) from);
  401.     break;
  402.   case T_LNG:
  403.     *(i4_t *) to = (i4_t) (*(i4_t *) from);
  404.     break;
  405.   case T_FLT:
  406.     *(i4_t *) to = (i4_t) (*(float *) from);
  407.     break;
  408.   case T_DBL:
  409.     *(i4_t *) to = (i4_t) (*(double *) from);
  410.     break;
  411.   default:
  412.     return (-ER_1); /* ERROR */
  413.   } /* switch */
  414. break;
  416.       case T_LNG:
  417. switch (from_mask)
  418.   {
  419.   case T_SRT:
  420.     *(i4_t *) to = (i4_t) (*(i2_t *) from);
  421.     break;
  422.   case T_INT:
  423.     *(i4_t *) to = (i4_t) (*(i4_t *) from);
  424.     break;
  425.   case T_FLT:
  426.     *(i4_t *) to = (i4_t) (*(float *) from);
  427.     break;
  428.   case T_DBL:
  429.     *(i4_t *) to = (i4_t) (*(double *) from);
  430.     break;
  431.   default:
  432.     return (-ER_1); /* ERROR */
  433.   } /* switch */
  434. break;
  436.       case T_FLT:
  437. switch (from_mask)
  438.   {
  439.   case T_SRT:
  440.     *(float *) to = (float) (*(i2_t *) from);
  441.     break;
  442.   case T_INT:
  443.     *(float *) to = (float) (*(i4_t *) from);
  444.     break;
  445.   case T_LNG:
  446.     *(float *) to = (float) (*(i4_t *) from);
  447.     break;
  448.   case T_DBL:
  449.     *(float *) to = (float) (*(double *) from);
  450.     break;
  451.   default:
  452.     return (-ER_1); /* ERROR */
  453.   } /* switch */
  454. break;
  456.       case T_DBL:
  457. switch (from_mask)
  458.   {
  459.   case T_SRT:
  460.     *(double *) to = (double) (*(i2_t *) from);
  461.     break;
  462.   case T_INT:
  463.     *(double *) to = (double) (*(i4_t *) from);
  464.     break;
  465.   case T_LNG:
  466.     *(double *) to = (double) (*(i4_t *) from);
  467.     break;
  468.   case T_FLT:
  469.     *(double *) to = (double) (*(float *) from);
  470.     break;
  471.   default:
  472.     return (-ER_1); /* ERROR */
  473.   } /* switch */
  474. break;
  475.       default:
  476. return (-ER_1); /* ERROR */
  477.       } /* switch,if,if */
  478.   return (0);
  479. } /* "put" */
  481. int
  482. is_casted(sql_type_t pt1,sql_type_t pt2)
  483. {
  484.   sql_type_t t3, t1=pt1, t2=pt2;
  485.   
  486.   if ( *(i4_t*)&t1 == *(i4_t*)&t2 )
  487.     return 1;
  488.   
  489.   if ( t1.code != t2.code )
  490.     {
  491.       static struct cast { 
  492. SQLType from,to; 
  493.       } casting[] = { { SQLType_0      ,SQLType_Char   },
  494.       { SQLType_0      ,SQLType_Short  },
  495.       { SQLType_Char   ,SQLType_Cstring},
  496.       { SQLType_Short  ,SQLType_Int    },
  497.       { SQLType_Int    ,SQLType_Long   },
  498.       { SQLType_Long   ,SQLType_Real   },
  499.       { SQLType_Long   ,SQLType_Num    },
  500.       { SQLType_Num    ,SQLType_Float  },
  501.       { SQLType_Real   ,SQLType_Double },
  502.       { SQLType_Double ,SQLType_Float  },
  503.       { SQLType_Real   ,SQLType_Double }  };
  504.       
  505.       register int i;
  506.       t3 = t2;
  507.       i = sizeof(casting)/sizeof(struct cast);
  508.       while (i--)
  509. {
  510.   if (t2.code != casting[i].from)
  511.     continue;
  512.   t3.code = casting[i].to;
  513.   if ( is_casted(t1,t3) )
  514.     return 1;
  515. }
  516.       return 0;
  517.     }
  518.   else /* (t1.code == t2.code) */
  519.     {
  520.       switch(t1.code)
  521. {
  522. case SQLType_Char: 
  523.   if (t2.len > t1.len)
  524.     return 0;
  525.   break;
  526. case SQLType_Num:
  527.   if ( t2.len - t2.prec > t1.len - t1.prec || t2.prec > t1.prec )
  528.     return 0;
  529.   break;
  530. case SQLType_Float:
  531.   if ( t2.len > t1.len)
  532.     return 0;
  533.   break;
  534. default:
  535.           break;
  536. }
  537.     }
  538.   return 1;
  539. }