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

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

SQL Server

开发平台：

Unix_Linux

groupby.k：源码内容
  1. /*
  2.  * groupby.c  -   'group by' transformation  
  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 Michael Kimelman.
  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: groupby.k,v 1.248 1997/04/24 18:41:28 kml Exp $ */
  30. #include "cycler.h"
  31. #include "opt.h"
  32. #include "cnf.h"
  33. #include "tree_gen.h"
  34. #include "tassert.h"
  35. #include <assert.h>
  37. /*
  38.   step in - save from in stack 
  39.   check where for correctness
  40.   save group_by list
  41.   check having and selection (if there are any aggregate function appliable
  42.                               to this level)
  43.   if MGoperation requred, create 3 lists (selection list for inner scan,
  44.   upper query scan column list and list of MAKEGROUP operation - 
  45.   [col0, col1, Avg(col2), Max(col2)... ] )
  46.     
  47.   from: 
  48.     DR- store context in stack and put 'selection' behind 'having';
  49.     RL - clear stack, generate 2-level query with makegroup (if needed) and replace
  50.          selection to the original place;
  51.   where,having,selection:
  52.     LD - set subtree_code;
  53.     DR - clear subtree_code
  54.   group by: move subtree to inner selection list & create sort list 
  55.   Aggregate functions: 
  56.     LD - set flag af+ ;
  57.     DR - clear flag af-, and replace node by colptr of tmp table
  58.   colptr - check for availability (!single column in having) and if af+ check for
  59.   one level columns in agr_func. columns from group by replaced by new colptrs
  60. */
  62. #define COL_N(c) XLNG_TRN(c,0)
  64. typedef struct {
  65.   enum token   query_code;
  66.   enum token   subtree_code;
  67.   i4_t          is_col_in_selection;
  68.   i4_t          one_row_groups;
  69.   TXTREF       sort_list; 
  70.   TXTREF       scol_list;
  71.   TXTREF       from;
  72.   TXTREF       selection;
  73.   TXTREF       into;      /* specially for SELECT statement */
  74.   TXTREF       where;
  75.   TXTREF       group_by;
  76.   TXTREF       having;
  77. } query_level_t;
  78.  
  79. DECL_STACK(gb,query_level_t); /* ';' added to make indent & emacs happy */
  81. /* the following two routines was wriiten to use from debugger */
  82.      
  83. static void
  84.      debug_frame(query_level_t *t)
  85. {
  86. #define F         fprintf
  87. #define E         STDERR
  88. #define BRANCH(v) F(E,"n%s:",#v)
  89.   BRANCH(subtree_code);        F(E,"%sn",NAME(t->subtree_code)); 
  90.   BRANCH(is_col_in_selection); F(E,"%dn",t->is_col_in_selection);
  91.   BRANCH(one_row_groups     ); F(E,"%dn",t->one_row_groups     );
  92.   BRANCH(sort_list);           debug_trn(t->sort_list);
  93.   BRANCH(scol_list);           debug_trn(t->scol_list);
  94.   BRANCH(from);                debug_trn(t->from);
  95.   BRANCH(selection);           debug_trn(t->selection);
  96.   BRANCH(where);               debug_trn(t->where);
  97.   BRANCH(group_by);            debug_trn(t->group_by);
  98.   BRANCH(having);              debug_trn(t->having);
  99. #undef F
  100. #undef E
  101. #undef BRANCH
  102. }
  104. void
  105. debug_gb_stack(i4_t i)
  106. {
  107.   i4_t depth;
  108.   query_level_t *st_frame;
  109.   
  110.   for(depth=0;depth < st_depth(gb_stack) && depth < i ;depth++)
  111.     {
  112.       fprintf(STDERR,
  113.               "---------------------------%d-%d-%d-%d-------------n",
  114.               depth,depth,depth,depth);
  115.       st_frame=SPTR(gb,depth);
  116.       debug_frame(st_frame);
  117.     }
  118. }
  120. static query_level_t *
  121. find_frame(TXTREF colptr)
  122. {
  123.   i4_t depth;
  124.   query_level_t *st_frame;
  125.   TXTREF scan = TNULL,ctblptr,t;
  126.   switch(CODE_TRN(colptr))
  127.     {
  128.     case COLPTR:
  129.       t = OBJ_DESC(colptr);
  130.       TASSERT(CODE_TRN(t)==SCOLUMN,colptr);
  131.       scan = COL_TBL(t); /* pointer to scan */
  132.       break;
  133.     case TBLPTR:
  134.       scan = TABL_DESC(colptr);
  135.       break;
  136.     default:
  137.       debug_trn(colptr);
  138.       yyfatal("Unexpected node in find_frame");
  139.     }
  140.   TASSERT(CODE_TRN(scan)==SCAN,colptr);
  141.   for(depth=0;depth < st_depth(gb_stack);depth++)
  142.     {
  143.       st_frame=SPTR(gb,depth);
  144.       for( ctblptr = DOWN_TRN(st_frame->from);
  145.            ctblptr;
  146.    ctblptr = RIGHT_TRN(ctblptr))
  147.         if (TABL_DESC(ctblptr) == scan)
  148.   return st_frame;
  149.     }
  150.   debug_trn(colptr);
  151.   yyfatal("Can't find given column in the frame list...");
  152.   return NULL;
  153. }
  155. static int
  156. is_unique(TXTREF clist)
  157. {
  158.   TXTREF tbl;
  159.   TXTREF ind,col,scan;
  160.   
  161.   TASSERT (CODE_TRN(clist)==COLPTR,clist);
  162.   /*     scan    scolumn  colptr */
  163.   scan = COL_TBL(OBJ_DESC(clist));
  164.   tbl  = COR_TBL(scan);
  165.   switch(CODE_TRN(tbl))
  166.     {
  167.     case TABLE:
  168.       ind=IND_INFO(tbl);
  169.       break;
  170.     case TMPTABLE:
  171.     case SCAN:
  172.     default:
  173.       return 0;
  174.     }
  175.   
  176.   while(ind)
  177.     {
  178.       if (CODE_TRN(ind)==UNIQUE || CODE_TRN(ind)==PRIMARY)
  179.         {
  180.           TXTREF clm;
  181.           TASSERT(ARITY_TRN(ind) > 0 && DOWN_TRN(ind) != TNULL, ind);
  182.           for (clm = DOWN_TRN(ind); clm ; clm = RIGHT_TRN(clm))
  183.             {
  184.               i4_t    id = COL_NO(OBJ_DESC(clm));
  185.               for (col = clist; col ; col = RIGHT_TRN(col))
  186.                 {
  187.                   TXTREF scol = OBJ_DESC(col);
  188.                   if ( COL_NO(scol) == id && COL_TBL(scol) == scan )
  189.                     break;
  190.                 }
  191.               if (!col) /* if not found */
  192.                 break;
  193.             }
  194.           if (!clm) /* unique key found for given list */
  195.             return 1;
  196.         }
  197.       ind = RIGHT_TRN(ind);
  198.     }
  199.   return 0;
  200. }
  202. #define FOR(link_name,cnt) if(!frame->link_name) 
  203.   frame->link_name = gen_node(NOOP); 
  204.   for(cnt=0,cptr=DOWN_TRN(frame->link_name);cptr;cptr=RIGHT_TRN(cptr),cnt++)
  206. #define CHECK_ERROR(msg) if(!cptr) { 
  207.   /*debug_trn(colptr);*/ yyfatal(msg); return TNULL;}
  209. static TXTREF 
  210. replace_function (TXTREF func  ,query_level_t *frame  ) 
  211. {
  212.   TXTREF cptr;
  213.   i4_t    counter,cno,dummy_cntr,count_all=0;
  214.   
  215.   TASSERT(Is_Function(func),func);
  217.   if (TstF_TRN(func,DISTINCT_F) && is_unique(DOWN_TRN(func)))
  218.     {
  219.       ClrF_TRN(func,DISTINCT_F);
  220.       if (CODE_TRN(func)==COUNT)
  221.         {
  222.           free_tree(DOWN_TRN(func));
  223.           ARITY_TRN(func) = 0;
  224.           DOWN_TRN(func) = TNULL;
  225.         }
  226.     }
  227.   
  228.   cptr = DOWN_TRN(func);
  229.   if (frame->one_row_groups==1) /* if we have a fictive selctions */
  230.     {
  231.       if (CODE_TRN(func)==COUNT)
  232.         cptr = #(Const "1" Int[10,0] Int[10,0] ) ;
  233.       else
  234.         cptr = DOWN_TRN(func);
  235.       free_node(func);
  236.       return cptr;
  237.     }
  238.   if(!cptr)
  239.     {
  240.       /* It looks to be 'count(*)' */
  241.       TASSERT(CODE_TRN(func)==COUNT && !TstF_TRN(func,DISTINCT_F),func);
  242.       if(!frame->group_by)
  243.         frame->group_by = gen_node(NOOP);
  244.       count_all = 1;
  245.       counter = 0;
  246.     }
  247.   else
  248.     {
  249.       FOR(group_by,counter)
  250. if(trn_equal_p(cptr,DOWN_TRN(func)))
  251.   break;
  252.       if(!cptr)
  253. {
  254.           TASSERT(RIGHT_TRN(DOWN_TRN(func))==TNULL,func);
  255.   add_child(frame->group_by,DOWN_TRN(func));
  256.           SetF_TRN(DOWN_TRN(func),EXACT_F);
  257. }
  258.     }
  259.   FOR(sort_list,cno)
  260.     if(CODE_TRN(cptr)==CODE_TRN(func) && MASK_TRN(cptr)==MASK_TRN(func) &&
  261.        ( count_all == 1 || COL_N(DOWN_TRN(cptr))==counter) )
  262.       break;
  263.   if(!cptr)
  264.     {
  265.       DOWN_TRN(func) = #(Col <counter> ) ;
  266.       RIGHT_TRN(func) = TNULL;
  267.       ARITY_TRN(func) = 1;
  268.       add_child(frame->sort_list,func);
  269.       cno++;
  270.     }
  271.   FOR(scol_list,dummy_cntr)
  272.     if(COL_NO(cptr)==cno /* || dummy_cntr==cno */ )
  273.       break;
  274.   if(!cptr)
  275.     {
  276.       char nm[100];
  277.       sprintf(nm,"%s_%d",NAME(CODE_TRN(func)),counter);
  278.       cptr =  #(SColumn <ltr_rec(nm)> <dummy_cntr> <OPRN_TYPE(func)> ) ;
  279.       add_child(frame->scol_list,cptr);
  280.       cno++;
  281.     }
  282.   return #(ColPtr <cptr> ) ;
  283. }
  285. static TXTREF 
  286. replace_clmn     (TXTREF colptr,query_level_t *frame) 
  287. {
  288.   TXTREF cptr;
  289.   i4_t    counter,cno;
  290.   char   msg[100],cn[100];
  292.   if (frame->one_row_groups==1) /* if we have a fictive grouping */
  293.     return colptr;
  295.   cptr = COR_TBL(COL_TBL(OBJ_DESC(colptr)));
  296.   sprintf(cn,"%s", STRING(COL_NAME(OBJ_DESC(colptr))));
  297.   sprintf(msg,"column '%s' isn't in `group by' clause",cn);
  298.   
  299.   FOR(group_by,counter) /* check column in group by list - selection clause
  300.    of inner query */
  301.     if(trn_equal_p(cptr,colptr))
  302.       break;
  303.   
  304.   CHECK_ERROR(msg);
  305.   if (TstF_TRN(cptr,EXACT_F))
  306.     yyfatal(msg);
  307.   FOR(sort_list,cno)    /* find reference to this column in sort list */
  308.     if(CODE_TRN(cptr)==COL && COL_N(cptr)==counter)
  309.       break;
  310.   CHECK_ERROR(msg);
  311.   FOR(scol_list,counter) /* find column of sorted scan */
  312.     if(COL_NO(cptr)==cno /* || counter==cno */ )
  313.       break;
  314.   CHECK_ERROR("Internal error: sort list and scan column list mismatch");
  315.   OBJ_DESC(colptr)=cptr;
  316.   return colptr;
  317. }
  319. static void
  320. process_gb_clmn  (TXTREF group_by,query_level_t *frame) 
  321. {
  322.   i4_t     counter;
  323.   TXTREF  cptr;
  324.   /* add new node in sort list and add column in scol_list */
  325.   TASSERT(CODE_TRN(group_by) == GROUP,group_by);
  326.   if (ARITY_TRN(frame->from)==1 && is_unique(DOWN_TRN(group_by)))  
  327.     { /* if we'll got just 1 row after selection */
  328.       frame->one_row_groups=1; /* if we have a fictive grouping */
  329.       return;
  330.     }
  331.   
  332.   FOR(group_by,counter)
  333.     {
  334.       TXTREF newscol,col=OBJ_DESC(cptr);
  335.       TASSERT(CODE_TRN(col)==SCOLUMN,group_by);
  336.       
  337.       COPY_NODE(SCOLUMN,col,newscol);
  338.       COL_TBL(newscol)=TNULL;
  339.       COL_NO(newscol)=counter;
  340.       COL_DEFAULT(newscol) = copy_tree(COL_DEFAULT(newscol));
  341.       
  342.       col = #(Col <counter>);
  343.       
  344.       if (!frame->scol_list)
  345.         frame->scol_list = gen_node(NOOP);
  346.       if (!frame->sort_list)
  347.         frame->sort_list = gen_node(NOOP);
  348.       
  349.       add_child(frame->scol_list,newscol);
  350.       add_child(frame->sort_list,col);
  351.     }
  352. }
  354. /*
  355.  * the extract_regular_query forms reqular query from query
  356.  * with group by when group by condition leds to only one row
  357.  * groups
  358.  */
  360. static TXTREF 
  361. extract_regular_query   (TXTREF query,query_level_t *frame)
  362. {
  363.   TXTREF Op[4];
  364.   i4_t    kitty_lcc; /* it looks to be need by (Run "..." ) */
  366.   TASSERT(frame->sort_list==TNULL,query);
  368.   Op[0] = query;
  369.   free_tree(frame->group_by);  /* erase fictive group list */
  371.   if (!frame->having)
  372.     Op[1] = frame->where;
  373.   else if (!frame->where)
  374.     {
  375.       Op[1] = frame->having;
  376.       CODE_TRN(Op[1]) = WHERE;
  377.     }
  378.   else
  379.     {
  380.       TASSERT(frame->having && frame->where,query);
  381.       Op[1] = #(Where { /* join condition in where & having */
  382.                  (Run "nested_assotiative"  
  383.                    (And {
  384.                      (DOWN (C_code "frame->where "))
  385.                      (DOWN (C_code "frame->having"))
  386.                    })
  387.                  )
  388.                });
  389.       free_node(frame->where);
  390.       free_node(frame->having);
  391.     }
  392.    
  393. # (Op:0 {
  394.      (C_code "frame->from" )
  395.      (C_code "frame->selection")
  396.      (Op:1)
  397.   }) ;
  398.     
  399.   return query;
  400. }
  402. static TXTREF 
  403. make_groupped_tbl       (TXTREF query,query_level_t *frame) 
  404. {
  405.   TXTREF t,s, iq, cptr;
  406.   i4_t    i,j;
  407.   enum token q_code;
  408.   
  409.   q_code = CODE_TRN(query);
  410.   TASSERT( q_code == QUERY ||
  411.            q_code == SELECT ||
  412.            q_code == SUBQUERY, query);
  413.   TASSERT( DOWN_TRN(query) == frame->from, query);
  414.   
  415.   TASSERT(frame->one_row_groups!=1,query);/*we don't have fictive grouping*/
  416.     
  417.   if (ARITY_TRN(frame->group_by)==0)  /* select count(*) from ..... */
  418.     {
  419.       TXTREF scan = TABL_DESC(DOWN_TRN(frame->from));
  420.       if (COR_COLUMNS(scan) == TNULL) /* if (select count(*) from table) */
  421.         add_column(scan,COL_NAME(TBL_COLS(COR_TBL(scan))));
  422.       DOWN_TRN(frame->group_by) = #(ColPtr (C_code "COR_COLUMNS(scan)"));
  423.       ARITY_TRN(frame->group_by) =1;
  424.     }
  425.   CODE_TRN(frame->group_by) = SELECTION;
  426.   FOR(group_by,i)
  427.     {
  428.       TASSERT(CODE_TRN(cptr)==COLPTR,cptr);
  429.       ClrF_TRN(cptr,EXACT_F);
  430.     }
  431.   if(frame->having)
  432.     CODE_TRN(frame->having) = WHERE;
  433.   iq =  
  434. #    (Query {  
  435.        (C_code "frame->from" )
  436.        (C_code "frame->group_by")
  437.        (C_code "frame->where")   
  438.      } )
  439.     ;
  440.   /* 'iq' points to inner query now */
  442.   t = DOWN_TRN(frame->group_by);
  443.   s = #(MakeGroup [] <make_scan(t,iq)> );
  444.   {
  445.     TXTREF t2,t1,v = gen_vect(ARITY_TRN(frame->scol_list));
  446.     TASSERT(ARITY_TRN(frame->scol_list) == ARITY_TRN(frame->sort_list),
  447.             frame->sort_list);
  448.     for(j=0,t1 = DOWN_TRN(frame->sort_list);t1;t1=t2,j++)
  449.       {
  450.         t2 = RIGHT_TRN(t1);
  451.         RIGHT_TRN(t1) = TNULL;
  452.         VOP(v,j).txtp = t1;
  453.       }
  454.     XVEC_TRN(s,0) = v;
  455.     free_node(frame->sort_list);
  456.     frame->sort_list = TNULL;
  457.   }
  458.   
  459.   t = gen_node(TMPTABLE);
  460.   VIEW_QUERY(t) = s;
  461.   add_info(t);
  462.   
  463.   {
  464.     char str[100];
  465.     s = #(Scan "" <-1> <t> );
  466.     add_info(s);                    /* Scan     */
  467.     sprintf(str,"gb_scan_%s_%s_%d",STRING(TBL_FNAME(t)),
  468.             STRING(TBL_NAME(t)),COR_NO(s));
  469.     COR_NAME(s) = ltr_rec(str);
  470.   }
  472.   for(i=0,t=DOWN_TRN(frame->scol_list);t;i++,t = RIGHT_TRN(t))
  473.     {
  474.       TXTREF t1;
  475.       
  476.       TASSERT(CODE_TRN(t) == SCOLUMN,t);
  477.       
  478.       COPY_NODE(COLUMN,t,t1);
  479.       COL_TBL(t1) = COR_TBL(s);
  480.       COL_TBL(t) = s;
  481.       COL_DEFAULT(t1) = copy_tree(COL_DEFAULT(t1));
  482.       
  483.       TASSERT(CODE_TRN(t1) == COLUMN,t1);
  484.       add_info(t1);  /* add tmptable column */
  485.       TASSERT(CODE_TRN(t1) == COLUMN,t1);
  486.     }
  487.   COR_COLUMNS(s) = DOWN_TRN(frame->scol_list);
  488.   t = COR_TBL(s);
  489.   TASSERT(TBL_NCOLS(t) == i,t);
  490.   TASSERT(ARITY_TRN(frame->scol_list) == i,frame->scol_list);
  491.   free_node(frame->scol_list);
  492.   frame->scol_list = TNULL;
  493.   SetF_TRN(t,CHECKED_F);
  494.   
  495.   {
  496.     TXTREF Op[1];
  497.     Op[0] = query;
  498. #   (Op:0 {
  499.       (From { (TblPtr (C_code "s")  ) } )
  500.       (C_code "frame->selection")
  501.       (C_code "frame->having")
  502.     } )
  503.       ;
  504.   }
  505.   if(TstF_TRN(query,HAVING_F))
  506.     {
  507.       SetF_TRN(query,WHERE_F);
  508.       ClrF_TRN(query,HAVING_F);
  509.     }
  510.   ClrF_TRN(query,GROUP_F);
  511.     
  512.   return query;
  513. }
  515. static void
  516. fix_into_subtree(TXTREF select,query_level_t *frame)
  517. {
  518.   TXTREF p,s;
  519. #define T(n) *node_type(n)
  520.   
  521.   TASSERT(frame->query_code==SELECT,select); 
  522.   
  523.   for ( p = DOWN_TRN(frame->into),s = DOWN_TRN(frame->selection);
  524.         p && s;
  525.         p = RIGHT_TRN(p), s = RIGHT_TRN(s))
  526.     {
  527.       TASSERT(CODE_TRN(p)==PARMPTR,frame->into);
  528.       if ( (T(p)).code == SQLType_0 )
  529.         T(p) = T(s);
  530.       else if (!is_casted(T(s),T(p)))
  531.         {
  532.           file_pos = LOCATION_TRN(p);
  533.           lperror("Parameter '%s' and selected expressions types mismatch",
  534.                   STRING(PAR_NAME(OBJ_DESC(p))));
  535.         }
  536.       adjust_parameter(p,s);
  537.           
  538.     }
  539.   if (p||s)
  540.     yyerror("there are different number of elements in 'selection' "
  541.             "and 'into' lists of SELECT statement");
  542.   /*  into      selection from     SELECT  */
  543.   p = RIGHT_TRN(s=RIGHT_TRN(DOWN_TRN(select)));
  544.   if (p && CODE_TRN(p)==INTO)
  545.     {
  546.       RIGHT_TRN(s) = RIGHT_TRN(p);
  547.       ARITY_TRN(select) --;
  548.     }
  549.   free_tree(frame->into);
  550. #undef T
  551. }
  553. #(Rule:static "upd_query"
  554.   (Query {
  555.     (From { (TblPtr (Scan:0)) })
  556.     --
  557.   } )  
  558.   "CODE_TRN(COR_TBL(Op[0]))==TABLE"
  559.   {}
  560. )
  563. static TXTREF
  564. skip_node(TXTREF n)
  565. {
  566.   free_tree(n);
  567.   return gen_node(NOOP);
  568. }
  570. #define LD (flag==CYCLER_LD)
  571. #define DR (flag==CYCLER_DR)
  572. #define RL (flag==CYCLER_RL)
  573. #define SUBTREE(branch)     
  574. if (gb_stack)           
  575. {    
  576.   cf=SPTR(gb,0);   
  577.   cf->subtree_code = (LD) ? CODE_TRN(node) : UNKNOWN ;   
  578.   if(LD) cf->branch = node;   
  579. }
  581. #define CLEAR(v) bzero(&v,sizeof(v))
  583. TXTREF 
  584. group_by_proc(TXTREF node,i4_t flag)
  585. {
  586.   
  587.   query_level_t *cf = NULL;
  588.   static i4_t            inside_function = 0;
  589.   static query_level_t *func_frame      = NULL;
  591. #if 0
  592.   fprintf(STDERR,"group_by:%s:%s:n:",NAME(CODE_TRN(node)),
  593.           (LD?"LD":(DR?"DR":(RL?"RL":"**"))));
  594. #endif
  595.   
  596.   switch(CODE_TRN(node))
  597.     {
  598.     case SELECT:
  599.     case QUERY:
  600.     case SUBQUERY:
  601.       if(LD)
  602. {
  603.   query_level_t frame;
  604.   CLEAR(frame);
  605.           frame.query_code = CODE_TRN(node);
  606.   PUSHS(gb,frame);
  607. }
  608.       else if(DR)
  609. {
  610.   query_level_t frame;
  611.           i4_t           distinct = TstF_TRN(node,DISTINCT_F);
  612.   POPS(gb,frame);
  613.   if(frame.scol_list == TNULL)
  614.             {
  615.               i4_t is_simple = 0;
  616.               if (frame.one_row_groups==1) /* if we have a fictive grouping */
  617.                 node = extract_regular_query(node,&frame);
  618.               rule_upd_query(&is_simple,node);
  619.               if (!is_simple)
  620.                 SetF_TRN(node,RO_F);
  621.             }
  622.           else
  623.             {
  624.               /* here we need to construct 2-level query with 
  625.                * makegroup operation
  626.                */
  627.               if (distinct)
  628.                 ClrF_TRN(node,DISTINCT_F);
  629.               node = make_groupped_tbl (node,&frame);
  630.               if (distinct)
  631.                 SetF_TRN(node,DISTINCT_F);
  632.               SetF_TRN(node,RO_F);
  633.             }
  634.           if (CODE_TRN(node) == SELECT)
  635.             fix_into_subtree(node,&frame);
  636. }
  637.       break;
  638.     case INTO:
  639.       SUBTREE(into);
  640.       if(gb_stack)
  641.         {
  642.           TASSERT(cf->query_code==SELECT,node);
  643.         }
  644.       break;
  645.     case FROM:
  646.       SUBTREE(from);
  647.       break;
  648.     case WHERE:
  649.       SUBTREE(where);
  650.       break;
  651.     case GROUP:
  652.       SUBTREE(group_by);
  653.       if(DR)
  654.         process_gb_clmn(node,cf);
  655.       break;
  656.     case HAVING:
  657.       SUBTREE(having);
  658.       break;
  659.     case SELECTION:   /* these subtrees must be processed after */
  660.     case RESULT:      /* group by and having                    */
  661.       if (RL)
  662.         {
  663.           extern TXTREF transformer __P((TXTREF in, i4_t f));
  665.           flag = CYCLER_LD;    /* left-2-down pass simulation */
  666.           SUBTREE(selection);
  667.           DOWN_TRN(node) = transformer(DOWN_TRN(node),0);
  668.           flag = CYCLER_RL;    /* recover pass info */
  669.           SUBTREE(selection);
  670.         }
  671.       else
  672.         cycler_skip_subtree = 1;
  673.       break;
  674.     case TBLPTR:
  675.       if (gb_stack && DR)
  676.         {
  677.           TXTREF tbl;
  678.           cf = find_frame(node);
  679.           tbl = COR_TBL(TABL_DESC(node));
  680.           /* do something smart */
  681.         }
  682.       break;
  683.     case COLPTR:
  684.       if (DR && gb_stack)
  685. {
  686.   cf = find_frame(node);
  687.   if (inside_function)
  688.     {
  689.       if (func_frame == NULL)
  690. func_frame = cf;
  691.       else if (func_frame !=  cf)
  692. yyerror("Aggregate function applied to incorrect expression");
  693.     }
  694.   else
  695.     {
  696.       switch(cf->subtree_code)
  697. {
  698. case FROM:
  699.                   file_pos = LOCATION_TRN(node);
  700.   yyfatal("using of columns isn't allowed in 'from' clause");
  701. case WHERE: /* do nothing - it's already ok */
  702.   break;
  703. case GROUP: /* we'll process them later */
  704.   break;
  705. case SELECTION:
  706. case RESULT:
  707.   if (cf->group_by==TNULL)
  708.     {
  709.       cf->is_col_in_selection = 1;
  710.       break;
  711.     }
  712. case HAVING:
  713.   node = replace_clmn(node,cf);
  714.   break;
  715. default:
  716.   yyfatal("Internal error: "
  717.                           "Column found in unexpected clause of query ");
  718. }
  719.     }
  720. }
  721.       break;
  722.     default: 
  723.       if (Is_Function(node))
  724. {
  725.           if(!gb_stack)
  726.             {
  727.               yyerror("illegal usage of aggregate function not in SELECT frame");
  728.               return skip_node(node);
  729.             }
  730.   if (LD)
  731.     {
  732.       assert(inside_function==0);
  733.       inside_function = 1;
  734.       func_frame = NULL;
  735.     }
  736.   else if (DR)
  737.     {
  738.       inside_function = 0;
  739.               if(!func_frame)
  740.                 func_frame = SPTR(gb,0);
  741.       switch(func_frame->subtree_code)
  742.         {
  743.                 case WHERE: 
  744.                   yyerror("illegal usage of aggregate function in "
  745.                           "WHERE clause");
  746.                   return skip_node(node);
  747.                   break;
  748.                 case SELECTION:
  749.                   if (func_frame->is_col_in_selection)
  750.                     {
  751.                       if (func_frame->is_col_in_selection==1)
  752.                         yyerror("Illegal usage both aggregate function"
  753.                                 " and columns in SELECT");
  754.                       func_frame->is_col_in_selection++;
  755.                       return skip_node(node);
  756.                     }
  757.                   break;
  758.                 default: break;
  759.                 }
  760.       node = replace_function(node,func_frame);
  761.       func_frame = NULL;
  762.     }
  763.         }
  764.     }
  765.   return node;
  766. }