LCOV - code coverage report
Current view: top level - sql/server - sql_symbol.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 116 116 100.0 %
Date: 2021-10-13 02:24:04 Functions: 17 17 100.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "sql_mem.h"
      11             : #include "sql_symbol.h"
      12             : #include "sql_parser.h"
      13             : 
      14             : static symbol *
      15             : symbol_init(symbol *s, tokens token, symtype type )
      16             : {
      17     8746252 :         s->token = token;
      18     8746252 :         s->type = type;
      19             :         return s;
      20             : }
      21             : 
      22             : symbol *
      23      145863 : symbol_create(sql_allocator *sa, tokens token, char *data)
      24             : {
      25      145863 :         symbol *s = SA_NEW(sa, symbol);
      26             : 
      27      145863 :         if (s) {
      28             :                 symbol_init(s, token, type_string);
      29      145863 :                 s->data.sval = data;
      30             :         }
      31      145863 :         return s;
      32             : }
      33             : 
      34             : symbol *
      35     6615747 : symbol_create_list(sql_allocator *sa, tokens token, dlist *data)
      36             : {
      37     6615747 :         symbol *s = SA_NEW(sa, symbol);
      38             : 
      39     6615747 :         if (s) {
      40             :                 symbol_init(s, token, type_list);
      41     6615747 :                 s->data.lval = data;
      42             :         }
      43     6615747 :         return s;
      44             : }
      45             : 
      46             : symbol *
      47        4262 : symbol_create_int(sql_allocator *sa, tokens token, int data)
      48             : {
      49        4262 :         symbol *s = SA_NEW(sa, symbol);
      50             : 
      51        4262 :         if (s) {
      52             :                 symbol_init(s, token, type_int);
      53        4262 :                 s->data.i_val = data;
      54             :         }
      55        4262 :         return s;
      56             : }
      57             : 
      58             : symbol *
      59         148 : symbol_create_lng(sql_allocator *sa, tokens token, lng data)
      60             : {
      61         148 :         symbol *s = SA_NEW(sa, symbol);
      62             : 
      63         148 :         if (s) {
      64             :                 symbol_init(s, token, type_lng);
      65         148 :                 s->data.l_val = data;
      66             :         }
      67         148 :         return s;
      68             : }
      69             : 
      70             : symbol *
      71       82445 : symbol_create_symbol(sql_allocator *sa, tokens token, symbol *data)
      72             : {
      73       82445 :         symbol *s = SA_NEW(sa, symbol);
      74             : 
      75       82445 :         if (s) {
      76             :                 symbol_init(s, token, type_symbol);
      77       82445 :                 s->data.sym = data;
      78             :         }
      79       82445 :         return s;
      80             : }
      81             : 
      82             : static dnode *
      83    23371040 : dnode_create(sql_allocator *sa )
      84             : {
      85    23371040 :         dnode *n = SA_NEW(sa, dnode);
      86             : 
      87    23371040 :         if (n)
      88    23371040 :                 n->next = NULL;
      89    23371040 :         return n;
      90             : }
      91             : 
      92             : static dnode *
      93             : dnode_create_string(sql_allocator *sa, const char *data)
      94             : {
      95     7803492 :         dnode *n = dnode_create(sa);
      96             : 
      97     7803492 :         if (n) {
      98     7803492 :                 n->data.sval = (char*)data;
      99     7803492 :                 n->type = type_string;
     100             :         }
     101             :         return n;
     102             : }
     103             : static dnode *
     104             : dnode_create_list(sql_allocator *sa, dlist *data)
     105             : {
     106     3457599 :         dnode *n = dnode_create(sa);
     107             : 
     108     3457599 :         if (n) {
     109     3457599 :                 n->data.lval = data;
     110     3457599 :                 n->type = type_list;
     111             :         }
     112             :         return n;
     113             : }
     114             : static dnode *
     115             : dnode_create_int(sql_allocator *sa, int data)
     116             : {
     117     1819149 :         dnode *n = dnode_create(sa);
     118             : 
     119     1819149 :         if (n) {
     120     1819149 :                 n->data.i_val = data;
     121     1819149 :                 n->type = type_int;
     122             :         }
     123             :         return n;
     124             : }
     125             : static dnode *
     126             : dnode_create_lng(sql_allocator *sa, lng data)
     127             : {
     128        1927 :         dnode *n = dnode_create(sa);
     129             : 
     130        1927 :         if (n) {
     131        1927 :                 n->data.l_val = data;
     132        1927 :                 n->type = type_lng;
     133             :         }
     134             :         return n;
     135             : }
     136             : static dnode *
     137             : dnode_create_symbol(sql_allocator *sa, symbol *data)
     138             : {
     139     9587472 :         dnode *n = dnode_create(sa);
     140             : 
     141     9587472 :         if (n) {
     142     9587472 :                 n->data.sym = data;
     143     9587472 :                 n->type = type_symbol;
     144             :         }
     145             :         return n;
     146             : }
     147             : 
     148             : static dnode *
     149      701401 : dnode_create_type(sql_allocator *sa, sql_subtype *data)
     150             : {
     151      701401 :         dnode *n = dnode_create(sa);
     152             : 
     153      701401 :         if (n) {
     154      701401 :                 if (data)
     155      701399 :                         n->data.typeval = *data;
     156             :                 else
     157           2 :                         n->data.typeval.type = NULL;
     158      701401 :                 n->type = type_type;
     159             :         }
     160      701401 :         return n;
     161             : }
     162             : 
     163             : dlist *
     164    10003700 : dlist_create(sql_allocator *sa)
     165             : {
     166    10003700 :         dlist *l = SA_NEW(sa, dlist);
     167             : 
     168    10003700 :         if (l) {
     169    10003700 :                 l->h = l->t = NULL;
     170    10003700 :                 l->cnt = 0;
     171             :         }
     172    10003700 :         return l;
     173             : }
     174             : 
     175             : int
     176     8933254 : dlist_length(dlist *l)
     177             : {
     178     8933254 :         return l->cnt;
     179             : }
     180             : 
     181             : static dlist *
     182             : dlist_append_default(dlist *l, dnode *n)
     183             : {
     184    23371040 :         if (l->cnt) {
     185    13369005 :                 l->t->next = n;
     186             :         } else {
     187    10002035 :                 l->h = n;
     188             :         }
     189    23371040 :         l->t = n;
     190    23371040 :         l->cnt++;
     191             :         return l;
     192             : }
     193             : 
     194             : dlist *
     195     7803492 : dlist_append_string(sql_allocator *sa, dlist *l, const char *data)
     196             : {
     197             :         dnode *n = dnode_create_string(sa, data);
     198             : 
     199     7803492 :         if (!n)
     200             :                 return NULL;
     201     7803492 :         return dlist_append_default(l, n);
     202             : }
     203             : 
     204             : dlist *
     205     3457599 : dlist_append_list(sql_allocator *sa, dlist *l, dlist *data)
     206             : {
     207             :         dnode *n = dnode_create_list(sa, data);
     208             : 
     209     3457599 :         if (!n)
     210             :                 return NULL;
     211     3457599 :         return dlist_append_default(l, n);
     212             : }
     213             : 
     214             : dlist *
     215     1819149 : dlist_append_int(sql_allocator *sa, dlist *l, int data)
     216             : {
     217             :         dnode *n = dnode_create_int(sa, data);
     218             : 
     219     1819149 :         if (!n)
     220             :                 return NULL;
     221     1819149 :         return dlist_append_default(l, n);
     222             : }
     223             : 
     224             : dlist *
     225        1927 : dlist_append_lng(sql_allocator *sa, dlist *l, lng data)
     226             : {
     227             :         dnode *n = dnode_create_lng(sa, data);
     228             : 
     229        1927 :         if (!n)
     230             :                 return NULL;
     231        1927 :         return dlist_append_default(l, n);
     232             : }
     233             : 
     234             : dlist *
     235     9587472 : dlist_append_symbol(sql_allocator *sa, dlist *l, symbol *data)
     236             : {
     237             :         dnode *n = dnode_create_symbol(sa, data);
     238             : 
     239     9587472 :         if (!n)
     240             :                 return NULL;
     241     9587472 :         return dlist_append_default(l, n);
     242             : }
     243             : 
     244             : dlist *
     245      701401 : dlist_append_type(sql_allocator *sa, dlist *l, sql_subtype *data)
     246             : {
     247      701401 :         dnode *n = dnode_create_type(sa, data);
     248             : 
     249      701401 :         if (!n)
     250             :                 return NULL;
     251      701401 :         return dlist_append_default(l, n);
     252             : }
     253             : 
     254             : symbol *
     255      284699 : newSelectNode(sql_allocator *sa, int distinct, struct dlist *selection, struct dlist *into, symbol *from, symbol *where, symbol *groupby, symbol *having, symbol *orderby, symbol *name, symbol *limit, symbol *offset, symbol *sample, symbol *seed, symbol *window)
     256             : {
     257      284699 :         SelectNode *sn = SA_NEW(sa, SelectNode);
     258             :         symbol *s = (symbol *) sn;
     259             : 
     260      284699 :         if (s) {
     261             :                 symbol_init(s, SQL_SELECT, type_symbol);
     262      284699 :                 sn->distinct = distinct;
     263      284699 :                 sn->lateral = 0;
     264      284699 :                 sn->limit = limit;
     265      284699 :                 sn->offset = offset;
     266      284699 :                 sn->sample = sample;
     267      284699 :                 sn->seed = seed;
     268      284699 :                 sn->selection = selection;
     269      284699 :                 sn->into = into;
     270      284699 :                 sn->from = from;
     271      284699 :                 sn->where = where;
     272      284699 :                 sn->groupby = groupby;
     273      284699 :                 sn->having = having;
     274      284699 :                 sn->orderby = orderby;
     275      284699 :                 sn->name = name;
     276      284699 :                 sn->window = window;
     277             :         }
     278      284699 :         return s;
     279             : }
     280             : 
     281             : symbol *
     282     1613088 : newAtomNode(sql_allocator *sa, atom *data)
     283             : {
     284     1613088 :         AtomNode *an = SA_NEW(sa, AtomNode);
     285             :         symbol *s = (symbol *) an;
     286             : 
     287     1613088 :         if (s) {
     288             :                 symbol_init(s, SQL_ATOM, type_symbol);
     289     1613088 :                 an->a = data;
     290             :         }
     291     1613088 :         return s;
     292             : }

Generated by: LCOV version 1.14