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 "res_table.h"
      15             : #include "bat_utils.h"
      16             : #include "sql_types.h"
      17             : 
      18             : static void
      19      253600 : bat_incref(bat bid)
      20             : {
      21      253600 :         BBPretain(bid);
      22      253602 : }
      23             : 
      24             : static void
      25      253586 : bat_decref(bat bid)
      26             : {
      27      253586 :         BBPrelease(bid);
      28      253581 : }
      29             : 
      30             : res_table *
      31      121936 : res_table_create(sql_trans *tr, int res_id, oid query_id, int nr_cols, mapi_query_t type, res_table *next)
      32             : {
      33      121936 :         res_table *t = MNEW(res_table);
      34      121939 :         res_col *tcols = ZNEW_ARRAY(res_col, nr_cols);
      35             : 
      36      121940 :         (void) tr;
      37      121940 :         if (!t || !tcols) {
      38           0 :                 _DELETE(t);
      39           0 :                 _DELETE(tcols);
      40           0 :                 return NULL;
      41             :         }
      42             : 
      43      121940 :         *t = (res_table) {
      44             :                 .id = res_id,
      45             :                 .query_id = query_id,
      46             :                 .query_type = type,
      47             :                 .cols = tcols,
      48             :                 .nr_cols = nr_cols,
      49             :                 .next = next,
      50             :         };
      51             : 
      52      121940 :         return t;
      53             : }
      54             : 
      55             : res_col *
      56      322255 : res_col_create(sql_trans *tr, res_table *t, const char *tn, const char *name, const char *typename, int digits, int scale, bool isbat, char mtype, void *val, bool cached)
      57             : {
      58      322255 :         res_col *c = t->cols + t->cur_col;
      59      322255 :         BAT *b;
      60             : 
      61      322255 :         if (!sql_find_subtype(&c->type, typename, digits, scale))
      62         327 :                 sql_init_subtype(&c->type, sql_trans_bind_type(tr, NULL, typename), digits, scale);
      63      322250 :         c->tn = _STRDUP(tn);
      64      322257 :         c->name = _STRDUP(name);
      65      322255 :         if (c->tn == NULL || c->name == NULL) {
      66           0 :                 _DELETE(c->tn);
      67           0 :                 _DELETE(c->name);
      68           0 :                 return NULL;
      69             :         }
      70      322255 :         c->b = 0;
      71      322255 :         c->p = NULL;
      72      322255 :         c->mtype = mtype;
      73      322255 :         if (isbat) {
      74      260741 :                 b = (BAT*)val;
      75      260741 :                 if (b && t->cur_col == 0)
      76       61212 :                         t->nr_rows = BATcount(b);
      77             :         } else { // wrap scalar values in BATs for result consistency
      78       61514 :                 b = COLnew(0, mtype, 1, TRANSIENT);
      79       61512 :                 if (b == NULL) {
      80           0 :                         _DELETE(c->tn);
      81           0 :                         _DELETE(c->name);
      82           0 :                         return NULL;
      83             :                 }
      84       61512 :                 if (BUNappend(b, val, false) != GDK_SUCCEED) {
      85           0 :                         BBPreclaim(b);
      86           0 :                         _DELETE(c->tn);
      87           0 :                         _DELETE(c->name);
      88           0 :                         return NULL;
      89             :                 }
      90       61505 :                 if (t->cur_col == 0)
      91       60713 :                         t->nr_rows = 1;
      92             :                 cached = true; /* simply keep memory pointer for this small bat */
      93             :         }
      94      322246 :         c->b = b->batCacheid;
      95      322246 :         c->cached = cached;
      96      322246 :         if (cached)
      97       68646 :                 c->p = (void*)b;
      98             :         else
      99      253600 :                 bat_incref(c->b);
     100      322248 :         t->cur_col++;
     101      322248 :         assert(t->cur_col <= t->nr_cols);
     102             :         return c;
     103             : }
     104             : 
     105             : static void
     106      322217 : res_col_destroy(res_col *c)
     107             : {
     108      322217 :         if (c->b && !c->cached) {
     109      253586 :                 bat_decref(c->b);
     110       68631 :         } else if (c->b) {
     111       68631 :                 bat_destroy((BAT*)c->p);
     112             :         } else {
     113           0 :                 _DELETE(c->p);
     114             :         }
     115      322206 :         _DELETE(c->name);
     116      322257 :         _DELETE(c->tn);
     117      322261 : }
     118             : 
     119             : void
     120      121861 : res_table_destroy(res_table *t)
     121             : {
     122      121861 :         int i;
     123             : 
     124      444157 :         for (i = 0; i < t->nr_cols; i++) {
     125      322221 :                 res_col *c = t->cols + i;
     126             : 
     127      322221 :                 if (c)
     128      322221 :                         res_col_destroy(c);
     129             :         }
     130      121936 :         _DELETE(t->cols);
     131      121940 :         _DELETE(t);
     132      121936 : }
     133             : 
     134             : res_table *
     135      118752 : res_tables_remove(res_table *results, res_table *t)
     136             : {
     137      118752 :         res_table *r = results;
     138             : 
     139      118752 :         if (r == t) {
     140      118752 :                 results = t->next;
     141             :         } else {
     142           0 :                 for (; r; r = r->next) {
     143           0 :                         if (r->next == t) {
     144           0 :                                 r->next = t->next;
     145           0 :                                 break;
     146             :                         }
     147             :                 }
     148             :         }
     149      118752 :         res_table_destroy(t);
     150      118770 :         return results;
     151             : }
     152             : 
     153             : void
     154       38032 : res_tables_destroy(res_table *tab)
     155             : {
     156       38032 :         if (tab) {
     157         175 :                 res_table *r = tab, *t;
     158             : 
     159         175 :                 for (t = r; t; t = r) {
     160         146 :                         r = t->next;
     161         146 :                         res_table_destroy(t);
     162             :                 }
     163             :         }
     164       38032 : }
     165             : 
     166             : res_table *
     167      244653 : res_tables_find(res_table *results, int res_id)
     168             : {
     169      244653 :         res_table *r = results;
     170             : 
     171      258433 :         for (; r; r = r->next) {
     172      254547 :                 if (r->id == res_id)
     173      240767 :                         return r;
     174             :         }
     175             :         return NULL;
     176             : }