Changeset: 9ecb465576a7 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/9ecb465576a7
Modified Files:
        sql/storage/bat/bat_storage.c
Branch: scatter
Log Message:

merged with jul2021


diffs (259 lines):

diff --git a/sql/storage/bat/bat_storage.c b/sql/storage/bat/bat_storage.c
--- a/sql/storage/bat/bat_storage.c
+++ b/sql/storage/bat/bat_storage.c
@@ -32,7 +32,7 @@ static int tc_gc_col( sql_store Store, s
 static int tc_gc_idx( sql_store Store, sql_change *c, ulng oldest);
 static int tc_gc_del( sql_store Store, sql_change *c, ulng oldest);
 
-static int tr_merge_delta( sql_trans *tr, sql_delta *obat);
+static int merge_delta( sql_delta *obat);
 
 /* valid
  * !deleted && VALID_4_READ(TS, tr)                            existing or 
newly created segment
@@ -1776,7 +1776,7 @@ static int
 commit_create_col_( sql_trans *tr, sql_column *c, ulng commit_ts, ulng oldest)
 {
        int ok = LOG_OK;
-       (void)oldest;
+       (void)tr; (void)oldest;
 
        if(!isTempTable(c->t)) {
                sql_delta *delta = ATOMIC_PTR_GET(&c->data);
@@ -1785,7 +1785,7 @@ commit_create_col_( sql_trans *tr, sql_c
 
                assert(delta->next == NULL);
                if (!delta->cs.alter)
-                       ok = tr_merge_delta(tr, delta);
+                       ok = merge_delta(delta);
                delta->cs.alter = 0;
                c->base.flags = 0;
        }
@@ -1876,7 +1876,7 @@ static int
 commit_create_idx_( sql_trans *tr, sql_idx *i, ulng commit_ts, ulng oldest)
 {
        int ok = LOG_OK;
-       (void)oldest;
+       (void)tr; (void)oldest;
 
        if(!isTempTable(i->t)) {
                sql_delta *delta = ATOMIC_PTR_GET(&i->data);
@@ -1884,7 +1884,7 @@ commit_create_idx_( sql_trans *tr, sql_i
                delta->cs.ts = commit_ts;
 
                assert(delta->next == NULL);
-               ok = tr_merge_delta(tr, delta);
+               ok = merge_delta(delta);
                i->base.flags = 0;
        }
        return ok;
@@ -2275,13 +2275,13 @@ drop_idx(sql_trans *tr, sql_idx *i)
 
 
 static BUN
-clear_cs(sql_trans *tr, column_storage *cs)
+clear_cs(sql_trans *tr, column_storage *cs, bool renew)
 {
        BAT *b;
        BUN sz = 0;
 
        (void)tr;
-       if (cs->bid) {
+       if (cs->bid && renew) {
                b = temp_descriptor(cs->bid);
                if (b) {
                        sz += BATcount(b);
@@ -2313,34 +2313,34 @@ clear_cs(sql_trans *tr, column_storage *
 }
 
 static BUN
-clear_col(sql_trans *tr, sql_column *c)
+clear_col(sql_trans *tr, sql_column *c, bool renew)
 {
        bool update_conflict = false;
        sql_delta *delta, *odelta = ATOMIC_PTR_GET(&c->data);
 
-       if ((delta = bind_col_data(tr, c, &update_conflict)) == NULL)
+       if ((delta = bind_col_data(tr, c, renew?&update_conflict:NULL)) == NULL)
                return update_conflict ? LOG_CONFLICT : LOG_ERR;
        if ((!inTransaction(tr, c->t) && (odelta != delta || isTempTable(c->t)) 
&& isGlobal(c->t)) || (!isNew(c->t) && isLocalTemp(c->t)))
                trans_add(tr, &c->base, delta, &tc_gc_col, &commit_update_col, 
isLocalTemp(c->t)?NULL:&log_update_col);
        if (delta)
-               return clear_cs(tr, &delta->cs);
+               return clear_cs(tr, &delta->cs, renew);
        return 0;
 }
 
 static BUN
-clear_idx(sql_trans *tr, sql_idx *i)
+clear_idx(sql_trans *tr, sql_idx *i, bool renew)
 {
        bool update_conflict = false;
        sql_delta *delta, *odelta = ATOMIC_PTR_GET(&i->data);
 
        if (!isTable(i->t) || (hash_index(i->type) && list_length(i->columns) 
<= 1) || !idx_has_column(i->type))
                return 0;
-       if ((delta = bind_idx_data(tr, i, &update_conflict)) == NULL)
+       if ((delta = bind_idx_data(tr, i, renew?&update_conflict:NULL)) == NULL)
                return update_conflict ? LOG_CONFLICT : LOG_ERR;
        if ((!inTransaction(tr, i->t) && (odelta != delta || isTempTable(i->t)) 
&& isGlobal(i->t)) || (!isNew(i->t) && isLocalTemp(i->t)))
                trans_add(tr, &i->base, delta, &tc_gc_idx, &commit_update_idx, 
isLocalTemp(i->t)?NULL:&log_update_idx);
        if (delta)
-               return clear_cs(tr, &delta->cs);
+               return clear_cs(tr, &delta->cs, renew);
        return 0;
 }
 
@@ -2349,7 +2349,7 @@ clear_storage(sql_trans *tr, storage *s)
 {
        BUN sz = count_deletes(s->segs->h, tr);
 
-       clear_cs(tr, &s->cs);
+       clear_cs(tr, &s->cs, true);
        s->cs.cleared = 1;
        if (s->segs)
                destroy_segments(s->segs);
@@ -2406,22 +2406,20 @@ clear_table(sql_trans *tr, sql_table *t)
        if ((clear_ok = clear_del(tr, t, in_transaction)) >= BUN_NONE - 1)
                return clear_ok;
 
-       if (clear) {
-               for (; n; n = n->next) {
-                       c = n->data;
-
-                       if ((clear_ok = clear_col(tr, c)) >= BUN_NONE - 1)
+       for (; n; n = n->next) {
+               c = n->data;
+
+               if ((clear_ok = clear_col(tr, c, clear)) >= BUN_NONE - 1)
+                       return clear_ok;
+       }
+       if (t->idxs) {
+               for (n = ol_first_node(t->idxs); n; n = n->next) {
+                       sql_idx *ci = n->data;
+
+                       if (isTable(ci->t) && idx_has_column(ci->type) &&
+                               (clear_ok = clear_idx(tr, ci, clear)) >= 
BUN_NONE - 1)
                                return clear_ok;
                }
-               if (t->idxs) {
-                       for (n = ol_first_node(t->idxs); n; n = n->next) {
-                               sql_idx *ci = n->data;
-
-                               if (isTable(ci->t) && idx_has_column(ci->type) 
&&
-                                       (clear_ok = clear_idx(tr, ci)) >= 
BUN_NONE - 1)
-                                       return clear_ok;
-                       }
-               }
        }
        return sz;
 }
@@ -2543,12 +2541,11 @@ log_storage(sql_trans *tr, sql_table *t,
 }
 
 static int
-tr_merge_cs( sql_trans *tr, column_storage *cs)
+merge_cs( column_storage *cs)
 {
        int ok = LOG_OK;
        BAT *cur = NULL;
 
-       (void)tr;
        if (cs->bid) {
                cur = temp_descriptor(cs->bid);
                if(!cur)
@@ -2592,15 +2589,15 @@ tr_merge_cs( sql_trans *tr, column_stora
 }
 
 static int
-tr_merge_delta( sql_trans *tr, sql_delta *obat)
+merge_delta( sql_delta *obat)
 {
-       return tr_merge_cs(tr, &obat->cs);
+       return merge_cs(&obat->cs);
 }
 
 static int
-tr_merge_storage(sql_trans *tr, storage *tdb)
+merge_storage(storage *tdb)
 {
-       int ok = tr_merge_cs(tr, &tdb->cs);
+       int ok = merge_cs(&tdb->cs);
 
        if (tdb->next) {
                ok = destroy_storage(tdb->next);
@@ -2643,12 +2640,6 @@ rollback_delta(sql_trans *tr, sql_delta 
 }
 
 static int
-commit_delta(sql_trans *tr, sql_delta *delta)
-{
-       return tr_merge_delta(tr, delta);
-}
-
-static int
 log_update_col( sql_trans *tr, sql_change *change)
 {
        sql_column *c = (sql_column*)change->obj;
@@ -2670,14 +2661,14 @@ commit_update_col_( sql_trans *tr, sql_c
        if (isTempTable(c->t)) {
                if (commit_ts) { /* commit */
                        if (c->t->commit_action == CA_COMMIT || 
c->t->commit_action == CA_PRESERVE)
-                               commit_delta(tr, delta);
+                               merge_delta(delta);
                        else /* CA_DELETE as CA_DROP's are gone already (or for 
globals are equal to a CA_DELETE) */
-                               clear_cs(tr, &delta->cs);
+                               clear_cs(tr, &delta->cs, true);
                } else { /* rollback */
                        if (c->t->commit_action == CA_COMMIT/* || 
c->t->commit_action == CA_PRESERVE*/)
                                rollback_delta(tr, delta, 
c->type.type->localtype);
                        else /* CA_DELETE as CA_DROP's are gone already (or for 
globals are equal to a CA_DELETE) */
-                               clear_cs(tr, &delta->cs);
+                               clear_cs(tr, &delta->cs, true);
                }
                c->t->base.flags = c->base.flags = 0;
        }
@@ -2751,7 +2742,7 @@ commit_update_col( sql_trans *tr, sql_ch
                        }
                }
                if (ok == LOG_OK && delta == d && oldest == commit_ts)
-                       ok = tr_merge_delta(tr, delta);
+                       ok = merge_delta(delta);
        } else if (ok == LOG_OK && tr->parent) /* move delta into older and 
cleanup current save points */
                ATOMIC_PTR_SET(&c->data, savepoint_commit_delta(delta, 
commit_ts));
        return ok;
@@ -2780,14 +2771,14 @@ commit_update_idx_( sql_trans *tr, sql_i
        if (isTempTable(i->t)) {
                if (commit_ts) { /* commit */
                        if (i->t->commit_action == CA_COMMIT || 
i->t->commit_action == CA_PRESERVE)
-                               commit_delta(tr, delta);
+                               merge_delta(delta);
                        else /* CA_DELETE as CA_DROP's are gone already */
-                               clear_cs(tr, &delta->cs);
+                               clear_cs(tr, &delta->cs, true);
                } else { /* rollback */
                        if (i->t->commit_action == CA_COMMIT/* || 
i->t->commit_action == CA_PRESERVE*/)
                                rollback_delta(tr, delta, type);
                        else /* CA_DELETE as CA_DROP's are gone already */
-                               clear_cs(tr, &delta->cs);
+                               clear_cs(tr, &delta->cs, true);
                }
                i->t->base.flags = i->base.flags = 0;
        }
@@ -2830,7 +2821,7 @@ commit_update_idx( sql_trans *tr, sql_ch
                        }
                }
                if (ok == LOG_OK && delta == d && oldest == commit_ts)
-                       ok = tr_merge_delta(tr, delta);
+                       ok = merge_delta(delta);
        } else if (ok == LOG_OK && tr->parent) /* cleanup older save points */
                ATOMIC_PTR_SET(&i->data, savepoint_commit_delta(delta, 
commit_ts));
        return ok;
@@ -2927,7 +2918,7 @@ commit_update_del( sql_trans *tr, sql_ch
                        dbat->cs.ts = commit_ts;
                merge_segments(dbat->segs, tr, change, commit_ts, oldest);
                if (ok == LOG_OK && dbat == d && oldest == commit_ts)
-                       ok = tr_merge_storage(tr, dbat);
+                       ok = merge_storage(dbat);
        } else if (ok == LOG_OK && tr->parent) {/* cleanup older save points */
                merge_segments(dbat->segs, tr, change, commit_ts, oldest);
                ATOMIC_PTR_SET(&t->data, savepoint_commit_storage(dbat, 
commit_ts));
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to