LCOV - code coverage report
Current view: top level - sql/storage/bat - bat_utils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 52 61 85.2 %
Date: 2021-10-13 02:24:04 Functions: 12 12 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 "bat_utils.h"
      11             : 
      12             : void
      13    26060195 : bat_destroy(BAT *b)
      14             : {
      15    26060195 :         if (b)
      16    25035027 :                 BBPunfix(b->batCacheid);
      17    26060294 : }
      18             : 
      19             : BAT *
      20      123170 : bat_new(int tt, BUN size, role_t role)
      21             : {
      22      123170 :         BAT *bn = COLnew(0, tt, size, role);
      23      123170 :         if (bn)
      24      123170 :                 BBP_pid(bn->batCacheid) = 0;
      25      123170 :         return bn;
      26             : }
      27             : 
      28             : void
      29           2 : bat_clear(BAT *b)
      30             : {
      31           2 :         bat_set_access(b,BAT_WRITE);
      32           2 :         BATclear(b,true);
      33           2 :         bat_set_access(b,BAT_READ);
      34           2 : }
      35             : 
      36             : BAT *
      37    21046814 : temp_descriptor(log_bid b)
      38             : {
      39    21046814 :         return BATdescriptor((bat) b);
      40             : }
      41             : 
      42             : BAT *
      43      264603 : quick_descriptor(log_bid b)
      44             : {
      45      264603 :         return BBPquickdesc((bat) b);
      46             : }
      47             : 
      48             : void
      49      356067 : temp_destroy(log_bid b)
      50             : {
      51      356067 :         if (b)
      52      356067 :                 BBPrelease(b);
      53      356067 : }
      54             : 
      55             : log_bid
      56     1164376 : temp_dup(log_bid b)
      57             : {
      58     1164376 :         if (b)
      59     1164371 :                 BBPretain(b);
      60     1164567 :         return b;
      61             : }
      62             : 
      63             : log_bid
      64     1140390 : temp_create(BAT *b)
      65             : {
      66     1140390 :         temp_dup(b->batCacheid);
      67     1140611 :         return b->batCacheid;
      68             : }
      69             : 
      70             : log_bid
      71        1803 : temp_copy(log_bid b, bool renew, bool temp)
      72             : {
      73             :         /* make a copy of b, if temp is set only create a empty bat */
      74             :         BAT *o, *c = NULL;
      75             :         log_bid r;
      76             : 
      77        1803 :         if (!renew) {
      78           0 :                 if (!(o = temp_descriptor(b)))
      79             :                         return BID_NIL;
      80           0 :                 c = COLcopy(o, o->ttype, true, PERSISTENT);
      81           0 :                 bat_destroy(o);
      82           0 :                 if (!c)
      83             :                         return BID_NIL;
      84           0 :                 BATcommit(c, BUN_NONE);
      85             :         } else {
      86        1803 :                 if (!(o = quick_descriptor(b)))
      87             :                         return BID_NIL;
      88        1803 :                 if (!(c = bat_new(o->ttype, COLSIZE, PERSISTENT)))
      89             :                         return BID_NIL;
      90             :         }
      91        1803 :         if (!temp)
      92         586 :                 bat_set_access(c, BAT_READ);
      93        1803 :         r = temp_create(c);
      94        1803 :         bat_destroy(c);
      95        1803 :         return r;
      96             : }
      97             : 
      98             : BAT *ebats[MAXATOMS] = { NULL };
      99             : 
     100             : log_bid
     101     1014550 : e_bat(int type)
     102             : {
     103     1014550 :         if (ebats[type] == NULL &&
     104           0 :             (ebats[type] = bat_new(type, 0, TRANSIENT)) == NULL)
     105             :                 return BID_NIL;
     106     1014550 :         return temp_create(ebats[type]);
     107             : }
     108             : 
     109             : BAT *
     110     3301043 : e_BAT(int type)
     111             : {
     112     3301043 :         if (ebats[type] == NULL &&
     113           0 :             (ebats[type] = bat_new(type, 0, TRANSIENT)) == NULL)
     114             :                 return NULL;
     115     3301043 :         return temp_descriptor(ebats[type]->batCacheid);
     116             : }
     117             : 
     118             : int
     119         266 : bat_utils_init(void)
     120             : {
     121             :         int t;
     122             :         char name[32];
     123             : 
     124        8210 :         for (t=1; t<GDKatomcnt; t++) {
     125        7944 :                 if (t != TYPE_bat && BATatoms[t].name[0]) {
     126        7678 :                         ebats[t] = bat_new(t, 0, TRANSIENT);
     127        7678 :                         if(ebats[t] == NULL) {
     128           0 :                                 for (t = t - 1; t >= 1; t--)
     129           0 :                                         bat_destroy(ebats[t]);
     130             :                                 return -1;
     131             :                         }
     132        7678 :                         bat_set_access(ebats[t], BAT_READ);
     133             :                         /* give it a name for debugging purposes */
     134        7678 :                         snprintf(name, sizeof(name), "sql_empty_%s_bat",
     135             :                                  ATOMname(t));
     136        7678 :                         BBPrename(ebats[t]->batCacheid, name);
     137             :                 }
     138             :         }
     139             :         return 0;
     140             : }

Generated by: LCOV version 1.14