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 "sql_catalog.h"
      15             : #include "sql_storage.h"
      16             : 
      17             : #include "gdk_atoms.h"
      18             : 
      19             : static inline int
      20        1173 : node_key( node *n )
      21             : {
      22        1173 :         sql_base *b = n->data;
      23           0 :         return hash_key(b->name);
      24             : }
      25             : 
      26             : objlist *
      27      382252 : ol_new(allocator *sa, destroy_fptr destroy, sql_store store)
      28             : {
      29      382252 :         objlist *ol = SA_NEW(sa, objlist);
      30      764504 :         *ol = (objlist) {
      31      382252 :                 .l = list_new(sa, (fdestroy)destroy),
      32      382252 :                 .h = hash_new(sa, 16, (fkeyvalue)&node_key),
      33             :                 .store = store
      34             :         };
      35      382252 :         return ol;
      36             : }
      37             : 
      38             : void
      39      244592 : ol_destroy(objlist *ol, sql_store store)
      40             : {
      41      244592 :         if (!ol->l->sa) {
      42      244592 :                 hash_destroy(ol->h);
      43      244592 :                 list_destroy2(ol->l, store);
      44      244592 :                 _DELETE(ol);
      45             :         }
      46      244592 : }
      47             : 
      48             : int
      49      792526 : ol_add(objlist *ol, sql_base *data)
      50             : {
      51      792526 :         list *l = list_append(ol->l, data);
      52      792526 :         if (!l) {
      53           0 :                 if (ol->l->destroy)
      54           0 :                         ol->l->destroy(ol->store, data);
      55           0 :                 return -1;
      56             :         }
      57      792526 :         node *n = l->t;
      58      792526 :         assert(n->data == data);
      59      792526 :         int sz = list_length(ol->l);
      60      792526 :         if (ol->h->size <= sz) {
      61        7210 :                 hash_destroy(ol->h);
      62        7210 :                 ol->h = hash_new(ol->l->sa, 4*sz, (fkeyvalue)&node_key);
      63        7210 :                 if (ol->h == NULL)
      64             :                         return -1;
      65      193514 :                 for (node *n = ol->l->h; n; n = n->next) {
      66      186304 :                         if (hash_add(ol->h, base_key(n->data), n) == NULL)
      67             :                                 /* No need to clean, ie expect a full transaction rollback */
      68             :                                 return -1;
      69             :                 }
      70             :         } else {
      71      785316 :                 if (hash_add(ol->h, base_key(data), n) == NULL)
      72             :                         /* No need to clean, ie expect a full transaction rollback */
      73             :                         return -1;
      74             :         }
      75             :         return 0;
      76             : }
      77             : 
      78             : void
      79        1160 : ol_del(objlist *ol, sql_store store, node *n)
      80             : {
      81        2320 :         hash_del(ol->h, node_key(n), n);
      82        1160 :         list_remove_node(ol->l, store, n);
      83        1160 : }
      84             : 
      85             : node *
      86          13 : ol_rehash(objlist *ol, const char *oldname, node *n)
      87             : {
      88          26 :         hash_del(ol->h, hash_key(oldname), n);
      89          26 :         if (hash_add(ol->h, node_key(n), n) == NULL)
      90           0 :                 return NULL;
      91             :         return n;
      92             : }
      93             : 
      94             : node *
      95    14103317 : ol_find_name(objlist *ol, const char *name)
      96             : {
      97    14103317 :         int key = hash_key(name);
      98    14103317 :         sql_hash_e *he = ol->h->buckets[key&(ol->h->size-1)];
      99             : 
     100    16476845 :         for (; he; he = he->chain) {
     101    12943796 :                 node *n = he->value;
     102    12943796 :                 sql_base *b = n->data;
     103             : 
     104    12943796 :                 if (b->name && strcmp(b->name, name) == 0)
     105    10570268 :                         return n;
     106             :         }
     107             :         return NULL;
     108             : }
     109             : 
     110       36970 : node *ol_find_id(objlist *ol, sqlid id)
     111             : {
     112             :         /* if needed we could add hash on id's as well */
     113     1371082 :         for (node *n = ol->l->h; n; n = n->next) {
     114     1370984 :                 sql_base *b = n->data;
     115     1370984 :                 if (b->id == id)
     116       36872 :                         return n;
     117             :         }
     118             :         return NULL;
     119             : }