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      254902 : bat_incref(bat bid)
      20             : {
      21      254902 :         BBPretain(bid);
      22      254902 : }
      23             : 
      24             : static void
      25      254907 : bat_decref(bat bid)
      26             : {
      27      254907 :         BBPrelease(bid);
      28      254897 : }
      29             : 
      30             : res_table *
      31      122649 : res_table_create(sql_trans *tr, int res_id, oid query_id, int nr_cols, mapi_query_t type, res_table *next)
      32             : {
      33      122649 :         res_table *t = MNEW(res_table);
      34      122649 :         res_col *tcols = ZNEW_ARRAY(res_col, nr_cols);
      35             : 
      36      122649 :         (void) tr;
      37      122649 :         if (!t || !tcols) {
      38           0 :                 _DELETE(t);
      39           0 :                 _DELETE(tcols);
      40           0 :                 return NULL;
      41             :         }
      42             : 
      43      122649 :         *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      122649 :         return t;
      53             : }
      54             : 
      55             : res_col *
      56      323406 : res_col_create(sql_trans *tr, res_table *t, const char *tn, const char *name, const char *typename, int digits, int scale, char mtype, void *val, bool cached)
      57             : {
      58      323406 :         res_col *c = t->cols + t->cur_col;
      59      323406 :         BAT *b;
      60             : 
      61      323406 :         if (!sql_find_subtype(&c->type, typename, digits, scale))
      62         337 :                 sql_init_subtype(&c->type, sql_trans_bind_type(tr, NULL, typename), digits, scale);
      63      323400 :         c->tn = _STRDUP(tn);
      64      323416 :         c->name = _STRDUP(name);
      65      323411 :         if (c->tn == NULL || c->name == NULL) {
      66           0 :                 _DELETE(c->tn);
      67           0 :                 _DELETE(c->name);
      68           0 :                 return NULL;
      69             :         }
      70      323411 :         c->b = 0;
      71      323411 :         c->p = NULL;
      72      323411 :         c->mtype = mtype;
      73      323411 :         if (mtype == TYPE_bat) {
      74      261623 :                 b = (BAT*)val;
      75      261623 :                 if (b && t->cur_col == 0)
      76       61664 :                         t->nr_rows = BATcount(b);
      77             :         } else { // wrap scalar values in BATs for result consistency
      78       61788 :                 b = COLnew(0, mtype, 1, TRANSIENT);
      79       61788 :                 if (b == NULL) {
      80           0 :                         _DELETE(c->tn);
      81           0 :                         _DELETE(c->name);
      82           0 :                         return NULL;
      83             :                 }
      84       61788 :                 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       61788 :                 if (t->cur_col == 0)
      91       60985 :                         t->nr_rows = 1;
      92             :                 cached = true; /* simply keep memory pointer for this small bat */
      93             :         }
      94      323411 :         c->b = b->batCacheid;
      95      323411 :         c->cached = cached;
      96      323411 :         if (cached)
      97       68509 :                 c->p = (void*)b;
      98             :         else
      99      254902 :                 bat_incref(c->b);
     100      323411 :         t->cur_col++;
     101      323411 :         assert(t->cur_col <= t->nr_cols);
     102             :         return c;
     103             : }
     104             : 
     105             : static void
     106      323413 : res_col_destroy(res_col *c)
     107             : {
     108      323413 :         if (c->b && !c->cached) {
     109      254907 :                 bat_decref(c->b);
     110       68506 :         } else if (c->b) {
     111       68506 :                 bat_destroy((BAT*)c->p);
     112             :         } else {
     113           0 :                 _DELETE(c->p);
     114             :         }
     115      323405 :         _DELETE(c->name);
     116      323415 :         _DELETE(c->tn);
     117      323415 : }
     118             : 
     119             : void
     120      122648 : res_table_destroy(res_table *t)
     121             : {
     122      122648 :         int i;
     123             : 
     124      446063 :         for (i = 0; i < t->nr_cols; i++) {
     125      323414 :                 res_col *c = t->cols + i;
     126             : 
     127      323414 :                 if (c)
     128      323414 :                         res_col_destroy(c);
     129             :         }
     130      122649 :         _DELETE(t->cols);
     131      122649 :         _DELETE(t);
     132      122649 : }
     133             : 
     134             : res_table *
     135      119796 : res_tables_remove(res_table *results, res_table *t)
     136             : {
     137      119796 :         res_table *r = results;
     138             : 
     139      119796 :         if (r == t) {
     140      119796 :                 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      119796 :         res_table_destroy(t);
     150      119796 :         return results;
     151             : }
     152             : 
     153             : void
     154       38255 : res_tables_destroy(res_table *tab)
     155             : {
     156       38255 :         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       38255 : }
     165             : 
     166             : res_table *
     167      246594 : res_tables_find(res_table *results, int res_id)
     168             : {
     169      246594 :         res_table *r = results;
     170             : 
     171      260374 :         for (; r; r = r->next) {
     172      256360 :                 if (r->id == res_id)
     173      242580 :                         return r;
     174             :         }
     175             :         return NULL;
     176             : }