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 "bat_utils.h"
      15             : 
      16             : int
      17           0 : bat_fix(BAT *b)
      18             : {
      19           0 :         if (b)
      20           0 :                 return BBPfix(b->batCacheid);
      21             :         return 0;
      22             : }
      23             : 
      24             : void
      25    53589474 : bat_destroy(BAT *b)
      26             : {
      27    53589474 :         BBPreclaim(b);
      28    53586749 : }
      29             : 
      30             : BAT *
      31      316567 : bat_new(int tt, BUN size, role_t role)
      32             : {
      33      316567 :         BAT *bn = COLnew(0, tt, size, role);
      34      316648 :         if (bn)
      35      316648 :                 BBP_pid(bn->batCacheid) = 0;
      36      316648 :         return bn;
      37             : }
      38             : 
      39             : void
      40           0 : bat_clear(BAT *b)
      41             : {
      42           0 :         bat_set_access(b,BAT_WRITE);
      43           0 :         BATclear(b,true);
      44           0 :         bat_set_access(b,BAT_READ);
      45           0 : }
      46             : 
      47             : BAT *
      48    41646859 : temp_descriptor(log_bid b)
      49             : {
      50    41646859 :         return BATdescriptor((bat) b);
      51             : }
      52             : 
      53             : BAT *
      54      472570 : quick_descriptor(log_bid b)
      55             : {
      56      472570 :         return BBPquickdesc((bat) b);
      57             : }
      58             : 
      59             : void
      60      993364 : temp_destroy(log_bid b)
      61             : {
      62      993364 :         if (b)
      63      993359 :                 BBPrelease(b);
      64      993388 : }
      65             : 
      66             : log_bid
      67     1470386 : temp_dup(log_bid b)
      68             : {
      69     1470386 :         if (b)
      70     1470359 :                 BBPretain(b);
      71     1470591 :         return b;
      72             : }
      73             : 
      74             : log_bid
      75     1310228 : temp_create(BAT *b)
      76             : {
      77     1310228 :         temp_dup(b->batCacheid);
      78     1310317 :         return b->batCacheid;
      79             : }
      80             : 
      81             : log_bid
      82      155932 : temp_copy(log_bid b, bool renew, bool temp)
      83             : {
      84             :         /* make a copy of b, if temp is set only create a empty bat */
      85      155932 :         BAT *o, *c = NULL;
      86      155932 :         log_bid r;
      87             : 
      88      155932 :         if (!renew) {
      89           0 :                 if (!(o = temp_descriptor(b)))
      90             :                         return BID_NIL;
      91           0 :                 c = COLcopy(o, o->ttype, true, PERSISTENT);
      92           0 :                 bat_destroy(o);
      93           0 :                 if (!c)
      94             :                         return BID_NIL;
      95           0 :                 BATcommit(c, BUN_NONE);
      96             :         } else {
      97      155932 :                 if (!(o = quick_descriptor(b)))
      98             :                         return BID_NIL;
      99      155861 :                 if (!(c = bat_new(o->ttype, COLSIZE, PERSISTENT)))
     100             :                         return BID_NIL;
     101             :         }
     102      155949 :         if (!temp)
     103      155165 :                 bat_set_access(c, BAT_READ);
     104      155949 :         r = temp_create(c);
     105      155951 :         bat_destroy(c);
     106      155951 :         return r;
     107             : }
     108             : 
     109             : BAT *ebats[MAXATOMS] = { NULL };
     110             : 
     111             : log_bid
     112      990998 : e_bat(int type)
     113             : {
     114      990998 :         if (ebats[type] == NULL &&
     115           0 :             (ebats[type] = bat_new(type, 0, SYSTRANS)) == NULL)
     116             :                 return BID_NIL;
     117      990998 :         return temp_create(ebats[type]);
     118             : }
     119             : 
     120             : BAT *
     121    13120112 : e_BAT(int type)
     122             : {
     123    13120112 :         if (ebats[type] == NULL &&
     124           0 :             (ebats[type] = bat_new(type, 0, SYSTRANS)) == NULL)
     125             :                 return NULL;
     126    13120112 :         return temp_descriptor(ebats[type]->batCacheid);
     127             : }
     128             : 
     129             : int
     130         332 : bat_utils_init(void)
     131             : {
     132         332 :         int t;
     133         332 :         char name[32];
     134             : 
     135        9924 :         for (t=1; t<GDKatomcnt; t++) {
     136        9592 :                 if (BATatoms[t].name[0]) {
     137        9592 :                         ebats[t] = bat_new(t, 0, SYSTRANS);
     138        9592 :                         if(ebats[t] == NULL) {
     139           0 :                                 for (t = t - 1; t >= 1; t--)
     140           0 :                                         bat_destroy(ebats[t]);
     141             :                                 return -1;
     142             :                         }
     143        9592 :                         bat_set_access(ebats[t], BAT_READ);
     144             :                         /* give it a name for debugging purposes */
     145        9592 :                         snprintf(name, sizeof(name), "sql_empty_%s_bat",
     146             :                                  ATOMname(t));
     147        9592 :                         BBPrename(ebats[t], name);
     148             :                 }
     149             :         }
     150             :         return 0;
     151             : }