LCOV - code coverage report
Current view: top level - sql/server - rel_semantic.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 83 98 84.7 %
Date: 2024-04-25 23:25:41 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : #include "monetdb_config.h"
      14             : #include "sql_parser.h"
      15             : #include "sql_symbol.h"
      16             : #include "rel_semantic.h"
      17             : #include "rel_select.h"
      18             : #include "rel_updates.h"
      19             : #include "rel_trans.h"
      20             : #include "rel_schema.h"
      21             : #include "rel_psm.h"
      22             : #include "rel_sequence.h"
      23             : #include "rel_exp.h"
      24             : #include "sql_privileges.h"
      25             : 
      26             : #include <unistd.h>
      27             : #include <string.h>
      28             : #include <ctype.h>
      29             : 
      30             : sql_rel *
      31      195463 : rel_parse(mvc *m, sql_schema *s, const char *query, char emode)
      32             : {
      33      195463 :         sql_rel *rel = NULL;
      34      195463 :         buffer *b;
      35      195463 :         bstream *bs;
      36      195463 :         stream *buf;
      37      195463 :         char *n;
      38      195463 :         size_t len = _strlen(query);
      39      195463 :         sql_schema *c = cur_schema(m);
      40      195463 :         sql_query *qc = NULL;
      41             : 
      42      195463 :         if ((b = malloc(sizeof(buffer))) == NULL)
      43             :                 return NULL;
      44      195463 :         if ((n = malloc(len + 1 + 1)) == NULL) {
      45           0 :                 free(b);
      46           0 :                 return sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
      47             :         }
      48      195463 :         snprintf(n, len + 2, "%s\n", query);
      49      195463 :         len++;
      50      195463 :         buffer_init(b, n, len);
      51      195463 :         buf = buffer_rastream(b, "sqlstatement");
      52      195463 :         if(buf == NULL) {
      53           0 :                 buffer_destroy(b);
      54           0 :                 return sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
      55             :         }
      56      195463 :         bs = bstream_create(buf, b->len);
      57      195463 :         if(bs == NULL) {
      58           0 :                 buffer_destroy(b);
      59           0 :                 return sql_error(m, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
      60             :         }
      61      195463 :         mvc o = *m;
      62      195463 :         scanner_init( &m->scanner, bs, NULL);
      63      195463 :         m->scanner.mode = LINE_1;
      64      195463 :         bstream_next(m->scanner.rs);
      65             : 
      66      195463 :         m->qc = NULL;
      67      195463 :         m->emode = emode;
      68      195463 :         if (s)
      69      195463 :                 m->session->schema = s;
      70      195463 :         m->params = NULL;
      71      195463 :         m->sym = NULL;
      72      195463 :         m->errstr[0] = '\0';
      73      195463 :         m->session->status = 0;
      74             :         /* via views we give access to protected objects */
      75      195463 :         assert(emode == m_instantiate || emode == m_deps || emode == m_prepare);
      76      195463 :         m->user_id = USER_MONETDB;
      77             : 
      78      195463 :         (void) sqlparse(m);     /* blindly ignore errors */
      79      195463 :         qc = query_create(m);
      80      195463 :         rel = rel_semantic(qc, m->sym);
      81             : 
      82      195463 :         buffer_destroy(b);
      83      195463 :         bstream_destroy(m->scanner.rs);
      84             : 
      85      195463 :         m->sym = NULL;
      86      195463 :         o.frames = m->frames;        /* may have been realloc'ed */
      87      195463 :         o.sizeframes = m->sizeframes;
      88      195463 :         if (m->session->status || m->errstr[0]) {
      89          12 :                 int status = m->session->status;
      90             : 
      91          12 :                 strcpy(o.errstr, m->errstr);
      92          12 :                 *m = o;
      93          12 :                 m->session->status = status;
      94             :         } else {
      95      195451 :                 unsigned int label = m->label;
      96             : 
      97      195451 :                 while (m->topframes > o.topframes)
      98           0 :                         clear_frame(m, m->frames[--m->topframes]);
      99      195451 :                 *m = o;
     100      195451 :                 m->label = label;
     101             :         }
     102      195463 :         m->session->schema = c;
     103      195463 :         return rel;
     104             : }
     105             : 
     106             : sql_rel *
     107      782481 : rel_semantic(sql_query *query, symbol *s)
     108             : {
     109      782481 :         mvc *sql = query->sql;
     110      782481 :         if (!s)
     111             :                 return NULL;
     112             : 
     113      782481 :         switch (s->token) {
     114             : 
     115        3164 :         case TR_COMMIT:
     116             :         case TR_SAVEPOINT:
     117             :         case TR_RELEASE:
     118             :         case TR_ROLLBACK:
     119             :         case TR_START:
     120             :         case TR_MODE:
     121        3164 :                 return rel_transactions(query, s);
     122             : 
     123      215430 :         case SQL_CREATE_SCHEMA:
     124             :         case SQL_DROP_SCHEMA:
     125             : 
     126             :         case SQL_DECLARE_TABLE:
     127             :         case SQL_CREATE_TABLE:
     128             :         case SQL_CREATE_VIEW:
     129             :         case SQL_DROP_TABLE:
     130             :         case SQL_DROP_VIEW:
     131             :         case SQL_ALTER_TABLE:
     132             : 
     133             :         case SQL_COMMENT:
     134             : 
     135             :         case SQL_GRANT:
     136             :         case SQL_REVOKE:
     137             :         case SQL_GRANT_ROLES:
     138             :         case SQL_REVOKE_ROLES:
     139             : 
     140             :         case SQL_CREATE_ROLE:
     141             :         case SQL_DROP_ROLE:
     142             : 
     143             :         case SQL_CREATE_INDEX:
     144             :         case SQL_DROP_INDEX:
     145             : 
     146             :         case SQL_CREATE_USER:
     147             :         case SQL_DROP_USER:
     148             :         case SQL_ALTER_USER:
     149             : 
     150             :         case SQL_RENAME_COLUMN:
     151             :         case SQL_RENAME_SCHEMA:
     152             :         case SQL_RENAME_TABLE:
     153             :         case SQL_RENAME_USER:
     154             :         case SQL_SET_TABLE_SCHEMA:
     155             : 
     156             :         case SQL_CREATE_TYPE:
     157             :         case SQL_DROP_TYPE:
     158      215430 :                 return rel_schemas(query, s);
     159             : 
     160         406 :         case SQL_CREATE_SEQ:
     161             :         case SQL_ALTER_SEQ:
     162             :         case SQL_DROP_SEQ:
     163         406 :                 return rel_sequences(query, s);
     164             : 
     165      256424 :         case SQL_CREATE_FUNC:
     166             :         case SQL_DROP_FUNC:
     167             :         case SQL_DECLARE:
     168             :         case SQL_CALL:
     169             :         case SQL_SET:
     170             : 
     171             :         case SQL_CREATE_TABLE_LOADER:
     172             : 
     173             :         case SQL_CREATE_TRIGGER:
     174             :         case SQL_DROP_TRIGGER:
     175             : 
     176             :         case SQL_ANALYZE:
     177      256424 :                 return rel_psm(query, s);
     178             : 
     179      149632 :         case SQL_INSERT:
     180             :         case SQL_UPDATE:
     181             :         case SQL_DELETE:
     182             :         case SQL_TRUNCATE:
     183             :         case SQL_MERGE:
     184             :         case SQL_COPYFROM:
     185             :         case SQL_COPYINTO:
     186             :         case SQL_BINCOPYFROM:
     187             :         case SQL_BINCOPYINTO:
     188             :         case SQL_COPYLOADER:
     189      149632 :                 return rel_updates(query, s);
     190             : 
     191         285 :         case SQL_WITH:
     192         285 :                 return rel_with_query(query, s);
     193             : 
     194         182 :         case SQL_MULSTMT: {
     195         182 :                 dnode *d;
     196         182 :                 sql_rel *r = NULL;
     197             : 
     198         182 :                 if (!stack_push_frame(sql, "%MUL"))
     199           0 :                         return sql_error(sql, 02, SQLSTATE(HY013) MAL_MALLOC_FAIL);
     200         557 :                 for (d = s->data.lval->h; d; d = d->next) {
     201         378 :                         symbol *sym = d->data.sym;
     202         378 :                         sql_rel *nr = rel_semantic(query, sym);
     203             : 
     204         378 :                         if (!nr) {
     205           3 :                                 stack_pop_frame(sql);
     206           3 :                                 return NULL;
     207             :                         }
     208         375 :                         if (r)
     209         193 :                                 r = rel_list(sql->sa, r, nr);
     210             :                         else
     211             :                                 r = nr;
     212             :                 }
     213         179 :                 stack_pop_frame(sql);
     214         179 :                 return r;
     215             :         }
     216           0 :         case SQL_PREP:
     217             :         {
     218           0 :                 dnode *d = s->data.lval->h;
     219           0 :                 symbol *sym = d->data.sym;
     220           0 :                 sql_rel *r = rel_semantic(query, sym);
     221             : 
     222           0 :                 if (!r)
     223             :                         return NULL;
     224             :                 return r;
     225             :         }
     226             : 
     227      156958 :         case SQL_SELECT:
     228             :         case SQL_JOIN:
     229             :         case SQL_UNION:
     230             :         case SQL_EXCEPT:
     231             :         case SQL_INTERSECT:
     232             :         case SQL_VALUES:
     233      156958 :                 return rel_selects(query, s);
     234             : 
     235           0 :         default:
     236           0 :                 return sql_error(sql, 02, SQLSTATE(42000) "Symbol type not found");
     237             :         }
     238             : }

Generated by: LCOV version 1.14