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 "store_sequence.h"
      15             : #include "sql_storage.h"
      16             : 
      17             : void
      18        1790 : sequences_lock(sql_store Store)
      19             : {
      20        1790 :         sqlstore *store = Store;
      21        1790 :         MT_lock_set(&store->column_locks[NR_COLUMN_LOCKS-1]);
      22        1790 : }
      23             : 
      24             : void
      25        1790 : sequences_unlock(sql_store Store)
      26             : {
      27        1790 :         sqlstore *store = Store;
      28        1790 :         MT_lock_unset(&store->column_locks[NR_COLUMN_LOCKS-1]);
      29        1790 : }
      30             : 
      31             : typedef struct store_sequence {
      32             :         sqlid seqid;
      33             :         lng cur;
      34             :         bool intrans;
      35             : } store_sequence;
      36             : 
      37             : void
      38         759 : log_store_sequence(sql_store Store, void *s)
      39             : {
      40         759 :         sqlstore *store = Store;
      41         759 :         store_sequence *seq = s;
      42         759 :         store->logger_api.log_tsequence(store, seq->seqid,  seq->cur);
      43         759 :         seq->intrans = false;
      44         759 : }
      45             : 
      46             : int
      47         168 : seq_hash(void *s)
      48             : {
      49         168 :         store_sequence *seq = s;
      50         168 :         return seq->seqid;
      51             : }
      52             : 
      53             : static void
      54         168 : sequence_destroy( void *dummy, store_sequence *s )
      55             : {
      56         168 :         (void)dummy;
      57         168 :         _DELETE(s);
      58         168 : }
      59             : 
      60             : void
      61         335 : seq_hash_destroy( sql_hash *h )
      62             : {
      63         335 :         if (h == NULL || h->sa)
      64             :                 return ;
      65       11022 :         for (int i = 0; i < h->size; i++) {
      66       10688 :                 sql_hash_e *e = h->buckets[i];
      67             : 
      68       10856 :                 while (e) {
      69         168 :                         sql_hash_e *next = e->chain;
      70             : 
      71         168 :                         sequence_destroy(NULL, e->value);
      72         168 :                         _DELETE(e);
      73         168 :                         e = next;
      74             :                 }
      75             :         }
      76         334 :         _DELETE(h->buckets);
      77         334 :         _DELETE(h);
      78             : }
      79             : 
      80             : static store_sequence *
      81        1166 : sequence_lookup( sql_hash *h, sqlid id)
      82             : {
      83        1166 :         sql_hash_e *e = h->buckets[id & (h->size-1)];
      84        1174 :         while(e) {
      85         971 :                 sql_hash_e *next = e->chain;
      86         971 :                 store_sequence *s = e->value;
      87             : 
      88         971 :                 if (s->seqid == id)
      89         963 :                         return s;
      90             :                 e = next;
      91             :         }
      92             :         return NULL;
      93             : }
      94             : 
      95             : /* lock is held */
      96             : static store_sequence *
      97        1058 : update_sequence(sqlstore *store, store_sequence *s)
      98             : {
      99        1058 :         if (!s->intrans && !list_append(store->seqchanges, s))
     100             :                 return NULL;
     101        1058 :         s->intrans = true;
     102        1058 :         return s;
     103             : }
     104             : 
     105             : /* lock is held */
     106             : static store_sequence *
     107         168 : sequence_create(sqlstore *store, sql_sequence *seq )
     108             : {
     109         168 :         lng val = 0;
     110         168 :         store_sequence *s = NULL;
     111         168 :         s = MNEW(store_sequence);
     112         168 :         if(!s)
     113             :                 return NULL;
     114             : 
     115         168 :         *s = (store_sequence) {
     116         168 :                 .seqid = seq->base.id,
     117         168 :                 .cur = seq->start,
     118             :         };
     119             : 
     120         168 :         if (!isNew(seq) && store->logger_api.get_sequence(store, seq->base.id, &val ))
     121          13 :                 s->cur = val;
     122         168 :         if (!hash_add(store->sequences, seq_hash(s), s)) {
     123           0 :                 _DELETE(s);
     124           0 :                 return NULL;
     125             :         }
     126             :         return s;
     127             : }
     128             : 
     129             : int
     130          44 : seq_restart(sql_store Store, sql_sequence *seq, lng start)
     131             : {
     132          44 :         store_sequence *s;
     133          44 :         sqlstore *store = Store;
     134             : 
     135          44 :         assert(!is_lng_nil(start));
     136          44 :         sequences_lock(store);
     137          44 :         s = sequence_lookup(store->sequences, seq->base.id);
     138             : 
     139          44 :         if (!s) {
     140          35 :                 lng val = 0;
     141             : 
     142          35 :                 if (isNew(seq) || !store->logger_api.get_sequence(store, seq->base.id, &val )) {
     143          35 :                         sequences_unlock(store);
     144          35 :                         return 1;
     145             :                 } else {
     146           0 :                         s = sequence_create(store, seq);
     147           0 :                         if (!s) {
     148           0 :                                 sequences_unlock(store);
     149           0 :                                 return 0;
     150             :                         }
     151             :                 }
     152             :         }
     153           9 :         lng ocur = s->cur;
     154           9 :         s->cur = start;
     155           9 :         if (!update_sequence(store, s)) {
     156           0 :                 s->cur = ocur;
     157           0 :                 sequences_unlock(store);
     158           0 :                 return 0;
     159             :         }
     160           9 :         sequences_unlock(store);
     161           9 :         return 1;
     162             : }
     163             : 
     164             : int
     165        1050 : seqbulk_next_value(sql_store Store, sql_sequence *seq, lng cnt, lng* dest)
     166             : {
     167        1050 :         store_sequence *s;
     168        1050 :         sqlstore *store = Store;
     169             : 
     170             :         // either dest is an array of size cnt or dest is a normal pointer and cnt == 1.
     171             : 
     172        1050 :         assert(dest);
     173             : 
     174        1050 :         sequences_lock(store);
     175        1050 :         s = sequence_lookup(store->sequences, seq->base.id);
     176        1050 :         if (!s) {
     177         132 :                 s = sequence_create(store, seq);
     178         132 :                 if (!s) {
     179           0 :                         sequences_unlock(store);
     180           0 :                         return 0;
     181             :                 }
     182             :         }
     183             : 
     184        1050 :         lng min = seq->minvalue;
     185        1050 :         lng max = seq->maxvalue;
     186        1050 :         lng cur = s->cur;
     187             : 
     188        1050 :         if (!seq->cycle) {
     189        1032 :                 if ((seq->increment > 0 && s->cur > max) ||
     190          16 :                     (seq->increment < 0 && s->cur < min)) {
     191           1 :                         sequences_unlock(store);
     192           1 :                         return 0;
     193             :                 }
     194             :         }
     195        1049 :         bool store_unlocked = false;
     196        1049 :         if (seq->increment > 0) {
     197        1032 :                 lng inc = seq->increment; // new value = old value + inc;
     198             : 
     199        1032 :                 if (0 < cnt && !seq->cycle && !(max > 0 && s->cur < 0)) {
     200        1016 :                         if ((max - s->cur) >= ((cnt-1) * inc)) {
     201        1016 :                                 lng ocur = s->cur;
     202        1016 :                                 s->cur += inc * cnt;
     203             : 
     204        1016 :                                 if (!update_sequence(store, s)) {
     205           0 :                                         s->cur = ocur;
     206           0 :                                         sequences_unlock(store);
     207           0 :                                         return 0;
     208             :                                 }
     209        1016 :                                 sequences_unlock(store);
     210        1016 :                                 store_unlocked = true;
     211             :                         } else {
     212           0 :                                 sequences_unlock(store);
     213           0 :                                 return 0;
     214             :                         }
     215             :                 }
     216     2031409 :                 for(lng i = 0; i < cnt; i++) {
     217     2030377 :                         dest[i] = cur;
     218     2030377 :                         if ((GDK_lng_max - inc < cur) || ((cur += inc) > max)) {
     219             :                                 // overflow
     220           7 :                                 cur = (seq->cycle)?min:lng_nil;
     221             :                         }
     222             :                 }
     223             :         } else { // seq->increment < 0
     224          17 :                 lng inc = -seq->increment; // new value = old value - inc;
     225             : 
     226          17 :                 if (0 < cnt && !seq->cycle && !(min < 0 && s->cur > 0)) {
     227          15 :                         if ((s->cur - min) >= ((cnt-1) * inc)) {
     228          15 :                                 lng ocur = s->cur;
     229          15 :                                 s->cur -= inc * cnt;
     230             : 
     231          15 :                                 if (!update_sequence(store, s)) {
     232           0 :                                         s->cur = ocur;
     233           0 :                                         sequences_unlock(store);
     234           0 :                                         return 0;
     235             :                                 }
     236          15 :                                 sequences_unlock(store);
     237          15 :                                 store_unlocked = true;
     238             :                         } else {
     239           0 :                                 sequences_unlock(store);
     240           0 :                                 return 0;
     241             :                         }
     242             :                 }
     243          70 :                 for(lng i = 0; i < cnt; i++) {
     244          53 :                         dest[i] = cur;
     245          53 :                         if ((-GDK_lng_max + inc > cur) || ((cur -= inc)  < min)) {
     246             :                                 // underflow
     247           3 :                                 cur = (seq->cycle)?max:lng_nil;
     248             :                         }
     249             :                 }
     250             :         }
     251             : 
     252        1049 :         if (!store_unlocked) {
     253          18 :                 lng ocur = s->cur;
     254          18 :                 s->cur = cur;
     255             : 
     256          18 :                 if (!update_sequence(store, s)) {
     257           0 :                         s->cur = ocur;
     258           0 :                         sequences_unlock(store);
     259           0 :                         return 0;
     260             :                 }
     261          18 :                 sequences_unlock(store);
     262             :         }
     263             :         return 1;
     264             : }
     265             : 
     266             : int
     267         962 : seq_next_value(sql_store store, sql_sequence *seq, lng *val)
     268             : {
     269         962 :         return seqbulk_next_value(store, seq, 1, val);
     270             : }
     271             : 
     272             : int
     273          72 : seq_get_value(sql_store Store, sql_sequence *seq, lng *val)
     274             : {
     275          72 :         store_sequence *s;
     276          72 :         sqlstore *store = Store;
     277             : 
     278          72 :         *val = 0;
     279          72 :         sequences_lock(store);
     280          72 :         s = sequence_lookup(store->sequences, seq->base.id);
     281          72 :         if (!s) {
     282          36 :                 s = sequence_create(store, seq);
     283          36 :                 if (!s) {
     284           0 :                         sequences_unlock(store);
     285           0 :                         return 0;
     286             :                 }
     287             :         }
     288          72 :         *val = s->cur;
     289          72 :         sequences_unlock(store);
     290          72 :         return 1;
     291             : }