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

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

SQL Server

开发平台：

Unix_Linux

monitor.l：源码内容
  1. %{
  2. /*
  3.  *  monitor.l - DB line monitor
  4.  *            
  5.  *  $Id: monitor.l,v 1.248 1997/04/03 14:36:10 kml Exp $
  6.  *
  7.  *  This file is a part of GNU SQL Server
  8.  *
  9.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  10.  *  Developed at the Institute of System Programming, Russia
  11.  *  This file is written by Michael Kimelman.
  12.  * 
  13.  *  This program is free software; you can redistribute it and/or modify
  14.  *  it under the terms of the GNU General Public License as published by
  15.  *  the Free Software Foundation; either version 2 of the License, or
  16.  *  (at your option) any later version.
  17.  *
  18.  *  This program is distributed in the hope that it will be useful,
  19.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  *  GNU General Public License for more details.
  22.  *
  23.  *  You should have received a copy of the GNU General Public License
  24.  *  along with this program; if not, write to the Free Software
  25.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26.  *
  27.  *  Contact:  gss@ispras.ru
  28.  *
  29.  */
  30.   
  31. #include "xmem.h"
  32. #include "sql_decl.h"
  33. #include "sql.h"
  34. #include "dyn_funcs.h"
  35. #include <assert.h>
  36.   
  38. #define SWITCH_COND(cond)  { save_condition();BEGIN(cond);}
  39. #define REST_COND            rest_condition();
  41. #define SCANNER_NAME      yylex_extractor
  43. #ifdef YY_DECL
  44. #  undef YY_DECL
  45. #endif
  46. #define YY_DECL           i4_t SCANNER_NAME(void)
  48. YY_DECL;
  50. #define SQL_PROC(code)  if(code){return code;}
  52. static str_buf c_scanner_buffer={0,0,NULL};
  53. #define sql_str(s,l)  buffer_string(&c_scanner_buffer,s,l)
  55. static void  save_condition(YY_PROTO(void));
  56. static void  rest_condition(YY_PROTO(void));
  58. static char *statement_scanner_buffer=NULL;
  60. #define APPEND_BUFFER { sql_str(yytext,yyleng);} 
  61. #define POP_BUFFER pop_cl_buffer()
  62. #define NEW_LINE        {
  63.   if (smth_done) fprintf(stderr,"(:%d)>",++line_num);
  64.   else           fprintf(stderr,"FreeSQL(:%d)>",++line_num); }
  66. void pop_cl_buffer(void)
  67. {
  68.   register char *b=sql_str(NULL,0);
  69.   statement_scanner_buffer= (b?savestring(b):NULL);
  70. }
  72. %}
  74. %x SQL_str SQL_comment
  75. %s Start
  77. WS              [ tf]+
  78. NNS             [^A-Za-z0-9_]
  79. OPTWS           [ tf]*
  80. NOT_WS          [^ tfn]
  81. LET             [A-Za-z]
  82. SQL_STRT        ((EXEC[ t]+SQL)|("$"))
  84. %%
  85.     i4_t sql_str_d_quote=0;
  86.     static i4_t line_num = 0;
  87.     i4_t smth_done = 0;
  89.                          NEW_LINE;
  90.   /*********************************************
  91.    *        lexics of embedded SQL in C        *
  92.    *********************************************/
  93. ;                       {
  94.    POP_BUFFER;
  95.    SQL_PROC(1); 
  96.  }
  97. {WS}                  { if(smth_done) { APPEND_BUFFER; } }
  98. '                  {
  99.                            APPEND_BUFFER;
  100.                            smth_done = 1;
  101.    SWITCH_COND(SQL_str);
  102.  }
  103. "                  {
  104.                            APPEND_BUFFER;
  105.                            smth_done = 1;
  106.    sql_str_d_quote=1;
  107.    SWITCH_COND(SQL_str);
  108.  }
  109. "-"{2}                  {
  110.                            SWITCH_COND(SQL_comment);  
  111.  }
  112. n                  {
  113.                            if (smth_done)
  114.                              {
  115.                                APPEND_BUFFER;
  116.                              }
  117.                            NEW_LINE;
  118.  }
  119. .          {
  120.                            APPEND_BUFFER;
  121.                            smth_done = 1;
  122.  }
  123.   /*********************************************
  124.    *             SQL string recognizer         *
  125.    *********************************************/
  126. <SQL_str>'{2}           { APPEND_BUFFER; }
  127. <SQL_str>n              {
  128.                            yyerror(" Unterminated SQL string ");
  129.                            NEW_LINE;
  130.    REST_COND;
  131.          }
  132. <SQL_str>[^'"n]+      { APPEND_BUFFER; }
  133. <SQL_str>"{2}           { APPEND_BUFFER; }
  134. <SQL_str>"              {
  135.    APPEND_BUFFER ;
  136.            if(sql_str_d_quote) 
  137.                              {
  138.        sql_str_d_quote=0;
  139.        REST_COND;
  140.      }
  141.  }
  142. <SQL_str>'              {
  143.                            APPEND_BUFFER;
  144.    if(!sql_str_d_quote) 
  145.      {
  146.        REST_COND;
  147.      }
  148.  }
  149.   /*********************************************
  150.    *             SQL comment recognizer        *
  151.    *********************************************/
  152. <SQL_comment>.      /* do nothing */;
  153. <SQL_comment>n          {
  154.                            NEW_LINE;
  155.    REST_COND;
  156.  }
  157. %%
  159. typedef struct save_yy_cond {
  160.       i4_t yy_cond;
  161.       struct save_yy_cond *nxt;
  162.     } *sv_ys_ptr;
  164. static sv_ys_ptr save_yy_start=NULL;
  166. static void
  167. save_condition(YY_PROTO(void))
  168. {
  169.   register sv_ys_ptr nptr=(sv_ys_ptr)xmalloc(sizeof(struct save_yy_cond));
  170.   nptr->yy_cond=yy_start;
  171.   nptr->nxt=save_yy_start;
  172.   save_yy_start=nptr;
  173. #ifdef FLEX_DEBUG
  174.   if(yy_flex_debug)
  175.     fprintf(stderr,"n Lex: save condition :%d => (%d)n",
  176.             yy_start,nptr->yy_cond);
  177. #endif
  178. }
  180. static void
  181. rest_condition(YY_PROTO(void))
  182. {
  183.   register sv_ys_ptr nptr=save_yy_start;
  184.   if(nptr==NULL)
  185.     fatal("Lex: Impossible restore conditions before save it !",NULL);
  186.   yy_start=nptr->yy_cond;
  187.   save_yy_start=nptr->nxt;
  188. #ifdef FLEX_DEBUG
  189.   if(yy_flex_debug)
  190.     fprintf(stderr,"n Lex: restore condition :%d <=(%d)n",
  191.             yy_start,nptr->yy_cond);
  192. #endif
  193.   xfree(nptr);
  194. }
  196. int
  197. print_width(dyn_sql_type_code_t t,int len)
  198. {
  199.   switch(t)
  200.     {
  201.     case SQL__Long  : 
  202.     case SQL__Real  : return 10;
  203.     case SQL__Short : return  5;
  204.     case SQL__Double: return 15;
  205.     default:                   ;
  206.     }
  207.   return len; 
  208. }
  210. void
  211. error_rprt(char *st,int rc, char *stmt)
  212. {
  213.   fprintf(stderr,"n#### Error occured in '%s'n%snat "%s"n",
  214.           stmt,gsqlca.errmsg,st);
  215. }
  217. int
  218. main(int argc, char *argv[])
  219. {
  220.   static char buffer[4096*4];
  221.   int stmt = 0;
  222.   int rc;
  223.   int i,j;
  224.   static char *sps =
  225.     "                                                                       "
  226.     "                                                                       "
  227.     "                                                                       "
  228.     "                                                                       "
  229.     "                                                                       "
  230.     ;
  231.   yyin = stdin;
  232.   yyout = stderr;
  233. #if 0 
  234.   if (argc > 1)
  235.     {
  236.       char *host , *user, *passwd;
  237.       host   = argv[1];
  238.       user   = (argc > 2 ? argv[2]: getlogin() );
  239.       passwd = (argc > 3 ? argv[3]: NULL);
  240.       if(SQL__session(host,user,passwd)!=0)       /* Not implemented yet */
  241.         yyfatal("Can't connect to given host");
  242.     }
  243. #endif
  244.   
  245. #define CHECK(st) if((rc=SQL__##st)!=0){ error_rprt(#st,rc,statement_scanner_buffer); goto error; }
  246.   while(SCANNER_NAME())
  247.     {
  248.       char *b;
  249.       int   l = strlen(statement_scanner_buffer);
  250.       int  *clms = NULL;
  251.       
  252.       SQL_DESCR in,out;
  253.       
  254.       if(statement_scanner_buffer==NULL)
  255.         continue;
  256.       if(strncmp(statement_scanner_buffer,"select",strlen("select")))
  257.         {
  258.           /* if not select statement */
  259.           CHECK(execute_immediate(statement_scanner_buffer));
  260.           stmt++;
  261.           continue;
  262.         }
  264.       /* put select in parenthesys */
  265.       b = xmalloc(l+3);
  266.       b[0] = '(';
  267.       strcpy(b+1,statement_scanner_buffer);
  268.       strcat(b+1+l,")");
  269.       xfree(statement_scanner_buffer);
  270.       statement_scanner_buffer = b;
  271.           
  272.       b = xmalloc(20);
  273.       sprintf(b,"%dth Stmt",stmt++);
  275.       CHECK(prepare(b,statement_scanner_buffer));
  276.       CHECK(allocate_cursor(b,"CURSOR"));
  277.       in  = SQL__allocate_descr("IN",0);
  278.       out = SQL__allocate_descr("OUT",0);
  280.       CHECK(describe(b,1,in));
  281.       CHECK(describe(b,0,out));
  283.       clms = (int*)xmalloc(out->count*sizeof(int));
  284.       
  285.       /* open cursor and write headers */
  286.       j=1;
  287.       fprintf(stderr,"n|");
  288.       for( i=0; i < out->count; i++)
  289.         {
  290.           int jj, k = 0;
  291.           sql_descr_element_t *e = &(out->values[i]);
  292.           if (e->unnamed)
  293.             jj=fprintf(stderr," col_%03d ",i);
  294.           else
  295.             jj=fprintf(stderr," %s ",e->name);
  296.           k = print_width(e->type,e->length) - jj;
  297.           jj += fprintf(stderr,"%s|",sps+strlen(sps)- (k>0?k:0) );
  298.           clms [i] = jj - 1;
  299.           j += jj;
  300.         }
  302.       /* -------------------------------------------------*/
  303.       fprintf(stderr,"n");
  304.       for(i=j;i--;)
  305.         fprintf(stderr,"-");
  307.       if(in->count)
  308.         {
  309.           CHECK(open_cursor("CURSOR",in));
  310.         }
  311.       else
  312.         {
  313.           CHECK(open_cursor("CURSOR",NULL));
  314.         }
  315.         
  316.       while(1)
  317.         {
  318.           char oline[1024];
  319.           for( i=0; i < out->count; i++)
  320.             out->values[i].indicator = 0;
  322.           CHECK(fetch("CURSOR",out));
  323.           
  324.           if(SQLCODE!=0)
  325.             break;
  326.           
  327.           sprintf(oline,"n|");
  328.           for (i=0; i < out->count; i++)
  329.             {
  330.               int k ;
  331.               int kk = 0 ;
  332.               char buf[4096] ;
  333.               sql_descr_element_t *e = &(out->values[i]) ;
  334.               
  335.               if (e->indicator < 0)
  336.                 {
  337.                   if (!e->nullable)
  338.                     if (e->name)
  339.                       fprintf(stderr,"nindicator < 0 for 'not null' field '%s'",e->name);
  340.                     else
  341.                       fprintf(stderr,"nindicator < 0 for 'not null' field '%d'",i);
  342.                   sprintf(buf,"null");
  343.                 }
  344.               else switch(e->type)
  345.                 {
  346.                 case SQL__Char:
  347.                 case SQL__CharVar:
  348.                   sprintf(buf,"%s",(char*)e->data);
  349.                   break;
  350.                 case SQL__Double: /* DOUBLE */
  351.                 case SQL__Float: /* FLOAT  */
  352.                   sprintf(buf,"%g",*((double*)(e->data)));
  353.                   break;
  354.                 case SQL__Real: /* REAL   */
  355.                   sprintf(buf,"%g",*((float*)(e->data)));
  356.                   break;
  357.                 case SQL__Int: /* int */
  358.                   sprintf(buf,"%X",*((int*)(e->data)));
  359.                   break;
  360.                 case SQL__Short: /* small */
  361.                   sprintf(buf,"%d",(int)*((short*)(e->data)));
  362.                   break;
  363.                 default:
  364.                   sprintf(buf," **%d** ",e->type);
  365.                 }
  366.               assert(kk==0);
  367.               k = (clms[i] - strlen(buf))/2; 
  368.               if (k > 4*clms[i])
  369.                 {
  370.                   strcat(oline,"!!");
  371.                   k = 0;
  372.                 }
  373.               k = sprintf(oline+strlen(oline),"%s%s",
  374.                           sps + strlen(sps) - (k>0?k:0),buf);
  375.               k = clms[i] - k;
  376.               sprintf(oline+strlen(oline),"%s|",
  377.                       sps + strlen(sps) - (k>0?k:0));
  378.             }
  379.           fprintf(stderr,"%s",oline);
  380.         }
  381.       
  382.       /* -------------------------------------------------*/
  383.       fprintf(stderr,"n");
  384.       for(i=j;i--;)
  385.         fprintf(stderr,"-");
  386.       fprintf(stderr,"nn");
  387.       CHECK(close_cursor("CURSOR"));
  388.       CHECK(deallocate_prepare(b));
  389.     error:
  390.       SQL__deallocate_descr(&in);
  391.       SQL__deallocate_descr(&out);
  392.       xfree(clms);
  393.       xfree(b);
  394.       b = NULL;
  395.     }
  396.       
  397.   _SQL_commit();
  398.   return 0;
  399. }