LCOV - code coverage report
Current view: top level - sql/server - sql_qc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 78 80 97.5 %
Date: 2021-10-13 02:24:04 Functions: 7 8 87.5 %

          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             : 
      11             : #include "sql_qc.h"
      12             : #include "sql_mvc.h"
      13             : #include "sql_atom.h"
      14             : #include "rel_exp.h"
      15             : #include "gdk_time.h"
      16             : 
      17             : qc *
      18        9937 : qc_create(sql_allocator *sa, int clientid, int seqnr)
      19             : {
      20        9937 :         qc *r = SA_NEW(sa, qc);
      21        9937 :         if (!r)
      22             :                 return NULL;
      23        9937 :         *r = (qc) {
      24             :                 .clientid = clientid,
      25             :                 .id = seqnr,
      26             :         };
      27        9937 :         return r;
      28             : }
      29             : 
      30             : static void
      31         310 : cq_delete(int clientid, cq *q)
      32             : {
      33         310 :         if (q->name)
      34         310 :                 backend_freecode(clientid, q->name);
      35             :         /* q, params and name are allocated using sa, ie need to be delete last */
      36         310 :         if (q->sa)
      37         310 :                 sa_destroy(q->sa);
      38         310 : }
      39             : 
      40             : void
      41         207 : qc_delete(qc *cache, cq *q)
      42             : {
      43             :         cq *n, *p = NULL;
      44             : 
      45         207 :         if (cache) {
      46         208 :                 for (n = cache->q; n; p = n, n = n->next) {
      47         208 :                         if (n == q) {
      48         207 :                                 if (p) {
      49           1 :                                         p->next = q->next;
      50             :                                 } else {
      51         206 :                                         cache->q = q->next;
      52             :                                 }
      53         207 :                                 cq_delete(cache->clientid, q);
      54         207 :                                 cache->nr--;
      55         207 :                                 break;
      56             :                         }
      57             :                 }
      58             :         }
      59         207 : }
      60             : 
      61             : void
      62       14273 : qc_clean(qc *cache)
      63             : {
      64             :         cq *n, *p = NULL;
      65             : 
      66       14273 :         if (cache) {
      67       14310 :                 for (n = cache->q; n; ) {
      68          37 :                         p = n->next;
      69          37 :                         cq_delete(cache->clientid, n);
      70          37 :                         cache->nr--;
      71             :                         n = p;
      72             :                 }
      73       14273 :                 cache->q = NULL;
      74             :         }
      75       14273 : }
      76             : 
      77             : void
      78        9937 : qc_destroy(qc *cache)
      79             : {
      80             :         cq *q, *n;
      81             : 
      82        9937 :         if (cache) {
      83       10003 :                 for (q = cache->q; q; q = n) {
      84          66 :                         n = q->next;
      85             : 
      86          66 :                         cq_delete(cache->clientid, q);
      87          66 :                         cache->nr--;
      88             :                 }
      89             :         }
      90        9937 : }
      91             : 
      92             : cq *
      93        6060 : qc_find(qc *cache, int id)
      94             : {
      95             :         cq *q;
      96             : 
      97        6060 :         if (cache) {
      98        6061 :                 for (q = cache->q; q; q = q->next) {
      99        6051 :                         if (q->id == id) {
     100        6050 :                                 q->count++;
     101        6050 :                                 return q;
     102             :                         }
     103             :                 }
     104             :         }
     105             :         return NULL;
     106             : }
     107             : 
     108             : cq *
     109         310 : qc_insert(qc *cache, sql_allocator *sa, sql_rel *r, symbol *s, list *params, mapi_query_t type, char *cmd, int no_mitosis)
     110             : {
     111             :         int namelen;
     112         310 :         sql_func *f = SA_NEW(sa, sql_func);
     113         310 :         cq *n = SA_ZNEW(sa, cq);
     114             :         list *res = NULL;
     115             : 
     116         310 :         if (!n || !f || !cache)
     117             :                 return NULL;
     118         310 :         n->id = cache->id++;
     119         310 :         cache->nr++;
     120             : 
     121         310 :         n->sa = sa;
     122         310 :         n->rel = r;
     123         310 :         n->s = s;
     124             : 
     125         310 :         n->next = cache->q;
     126         310 :         n->type = type;
     127         310 :         n->count = 1;
     128         310 :         namelen = 5 + ((n->id+7)>>3) + ((cache->clientid+7)>>3);
     129         310 :         char *name = sa_alloc(sa, namelen);
     130         310 :         n->no_mitosis = no_mitosis;
     131         310 :         n->created = timestamp_current();
     132         310 :         if (!name)
     133             :                 return NULL;
     134         310 :         (void) snprintf(name, namelen, "p%d_%d", n->id, cache->clientid);
     135         310 :         n->name = name;
     136         310 :         cache->q = n;
     137             : 
     138         310 :         if (r && is_project(r->op) && !list_empty(r->exps)) {
     139             :                 sql_arg *a;
     140             :                 node *m;
     141             : 
     142         281 :                 res = sa_list(sa);
     143         814 :                 for(m = r->exps->h; m; m = m->next) {
     144         533 :                         sql_exp *e = m->data;
     145         533 :                         sql_subtype *t = exp_subtype(e);
     146             : 
     147             :                         a = NULL;
     148         533 :                         if (t)
     149         527 :                                 a = sql_create_arg(sa, NULL, t, ARG_OUT);
     150         533 :                         append(res, a);
     151             :                 }
     152             :         }
     153             : 
     154         310 :         *f = (sql_func) {
     155             :                 .mod = sql_private_module_name,
     156             :                 .type = F_PROC,
     157             :                 .query = cmd,
     158             :                 .ops = params,
     159             :                 .res = res,
     160             :         };
     161         310 :         base_init(sa, &f->base, 0, true, NULL);
     162         310 :         f->base.new = 1;
     163         310 :         f->base.id = n->id;
     164         310 :         f->base.name = f->imp = name;
     165         310 :         n->f = f;
     166         310 :         return n;
     167             : }
     168             : 
     169             : int
     170           0 : qc_size(qc *cache)
     171             : {
     172           0 :         return cache ? cache->nr : 0;
     173             : }

Generated by: LCOV version 1.14