Changeset: 5befa07017aa for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=5befa07017aa
Modified Files:
        sql/storage/bat/bat_storage.c
        sql/storage/store.c
Branch: Nov2019
Log Message:

make sure to set the write time (wtime) of an object (also on creation),
such that new transactions will properly use the active delta structures 
holding the
real data.
Removed ref counting structure (the list itself were not made for doing ref 
counting)


diffs (240 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
@@ -1081,7 +1081,8 @@ count_col(sql_trans *tr, sql_column *c, 
 {
        sql_delta *b;
 
-       if (!isTable(c->t)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(c->t))
                return 0;
        if (!c->data) {
                sql_column *oc = tr_find_column(tr->parent, c);
@@ -1101,7 +1102,8 @@ dcount_col(sql_trans *tr, sql_column *c)
 {
        sql_delta *b;
 
-       if (!isTable(c->t)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(c->t))
                return 0;
        if (!c->data) {
                sql_column *oc = tr_find_column(tr->parent, c);
@@ -1136,7 +1138,8 @@ count_idx(sql_trans *tr, sql_idx *i, int
 {
        sql_delta *b;
 
-       if (!isTable(i->t) || (hash_index(i->type) && list_length(i->columns) 
<= 1) || !idx_has_column(i->type)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(i->t) || (hash_index(i->type) && list_length(i->columns) 
<= 1) || !idx_has_column(i->type))
                return 0;
        if (!i->data) {
                sql_idx *oi = tr_find_idx(tr->parent, i);
@@ -1156,7 +1159,8 @@ count_del(sql_trans *tr, sql_table *t)
 {
        sql_dbat *d;
 
-       if (!isTable(t)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(t))
                return 0;
        if (!t->data) {
                sql_table *ot = tr_find_table(tr->parent, t);
@@ -1173,6 +1177,7 @@ count_col_upd(sql_trans *tr, sql_column 
 {
        sql_delta *b;
 
+       assert(tr->active || tr == gtrans);
        assert (isTable(c->t)) ;
        if (!c->data) {
                sql_column *oc = tr_find_column(tr->parent, c);
@@ -1189,7 +1194,8 @@ count_idx_upd(sql_trans *tr, sql_idx *i)
 {
        sql_delta *b;
 
-       if (!isTable(i->t) || (hash_index(i->type) && list_length(i->columns) 
<= 1) || !idx_has_column(i->type)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(i->t) || (hash_index(i->type) && list_length(i->columns) 
<= 1) || !idx_has_column(i->type))
                return 0;
        if (!i->data) {
                sql_idx *oi = tr_find_idx(tr->parent, i);
@@ -1207,7 +1213,8 @@ count_upd(sql_trans *tr, sql_table *t)
 {
        node *n;
 
-       if (!isTable(t)) 
+       assert(tr->active || tr == gtrans);
+       if (!isTable(t))
                return 0;
 
        for( n = t->columns.set->h; n; n = n->next) {
@@ -1233,6 +1240,7 @@ sorted_col(sql_trans *tr, sql_column *co
 {
        int sorted = 0;
 
+       assert(tr->active || tr == gtrans);
        if (!isTable(col->t) || !col->t->s)
                return 0;
        /* fallback to central bat */
@@ -1253,6 +1261,7 @@ double_elim_col(sql_trans *tr, sql_colum
 {
        int de = 0;
 
+       assert(tr->active || tr == gtrans);
        if (!isTable(col->t) || !col->t->s)
                return 0;
        /* fallback to central bat */
@@ -1471,7 +1480,7 @@ create_col(sql_trans *tr, sql_column *c)
        }
 
        if (!isNew(c) && !isTempTable(c->t)){
-               c->base.wtime = 0;
+               //c->base.wtime = 0;
                return load_bat(bat, type, c->t->bootstrap?0:LOG_COL, 
c->base.id);
        } else if (bat && bat->ibid && !isTempTable(c->t)) {
                return new_persistent_bat(tr, c->data, c->t->sz);
@@ -1571,7 +1580,7 @@ create_idx(sql_trans *tr, sql_idx *ni)
        }
 
        if (!isNew(ni) && !isTempTable(ni->t)){
-               ni->base.wtime = 0;
+               //ni->base.wtime = 0;
                return load_bat(bat, type, ni->t->bootstrap?0:LOG_IDX, 
ni->base.id);
        } else if (bat && bat->ibid && !isTempTable(ni->t)) {
                return new_persistent_bat( tr, ni->data, ni->t->sz);
@@ -1678,7 +1687,7 @@ create_del(sql_trans *tr, sql_table *t)
                log_bid bid = logger_find_bat(bat_logger, bat->dname, 
t->bootstrap?0:LOG_TAB, t->base.id);
 
                if (bid) {
-                       t->base.wtime = 0;
+                       //t->base.wtime = 0;
                        return load_dbat(bat, bid);
                }
                ok = LOG_ERR;
@@ -1924,6 +1933,8 @@ delayed_destroy_dbat(sql_dbat *b)
        while(n->next) 
                n = n->next;
        MT_lock_set(&destroy_lock);
+       while(n->next)
+               n = n->next;
        n->next = tobe_destroyed_dbat;
        tobe_destroyed_dbat = b;
        MT_lock_unset(&destroy_lock);
diff --git a/sql/storage/store.c b/sql/storage/store.c
--- a/sql/storage/store.c
+++ b/sql/storage/store.c
@@ -631,6 +631,7 @@ load_column(sql_trans *tr, sql_table *t,
                store_funcs.create_col(tr, c);
        c->sorted = sql_trans_is_sorted(tr, c);
        c->dcount = 0;
+       c->base.stime = c->base.wtime = tr->wstime;
        if (bs_debug)
                fprintf(stderr, "#\t\tload column %s\n", c->base.name);
        return c;
@@ -809,6 +810,7 @@ load_table(sql_trans *tr, sql_schema *s,
        t->cleared = 0;
        v = table_funcs.column_find_value(tr, find_sql_column(tables, 
"access"),rid);
        t->access = *(sht*)v;   _DELETE(v);
+       t->base.stime = t->base.wtime = tr->wstime;
 
        t->pkey = NULL;
        t->s = s;
@@ -1589,6 +1591,7 @@ bootstrap_create_column(sql_trans *tr, s
        col->unique = 0;
        col->storage_type = NULL;
        cs_add(&t->columns, col, TR_NEW);
+       col->base.wtime = col->t->base.wtime = col->t->s->base.wtime = 
tr->wtime = tr->wstime;
 
        if (isTable(col->t))
                store_funcs.create_col(tr, col);
@@ -1773,6 +1776,7 @@ bootstrap_create_table(sql_trans *tr, sq
        t->base.flags = s->base.flags;
        t->query = NULL;
        t->s = s;
+       t->base.wtime = t->s->base.wtime = tr->wtime = tr->wstime;
        cs_add(&s->tables, t, TR_NEW);
 
        if (isTable(t))
@@ -1811,7 +1815,7 @@ bootstrap_create_schema(sql_trans *tr, c
        s->keys = list_new(tr->sa, (fdestroy) NULL);
        s->idxs = list_new(tr->sa, (fdestroy) NULL);
        s->triggers = list_new(tr->sa, (fdestroy) NULL);
-
+       s->base.wtime = tr->wtime = tr->wstime;
        cs_add(&tr->schemas, s, TR_NEW);
 
        tr->schema_updates ++;
@@ -1851,7 +1855,9 @@ store_load(void) {
 
        if (!sequences_init())
                return -1;
+       ATOMIC_SET(&transactions, 0);
        gtrans = tr = create_trans(sa, backend_stk);
+       gtrans->stime = timestamp();
        if (!gtrans)
                return -1;
 
@@ -1868,6 +1874,7 @@ store_load(void) {
                        return -1;
                }
        } else {
+               tr->active = 1;
                if (!(store_oids = GDKzalloc(300 * sizeof(sqlid)))) { /* 150 
suffices */
                        fprintf(stderr, "Allocation failure while loading the 
storage\n");
                        return -1;
@@ -2033,6 +2040,7 @@ store_load(void) {
                }
                sql_trans_destroy(tr, true);
        } else {
+               tr->active = 0;
                GDKqsort(store_oids, NULL, NULL, nstore_oids, sizeof(sqlid), 0, 
TYPE_int, false, false);
                store_oid = store_oids[nstore_oids - 1] + 1;
        }
@@ -2044,12 +2052,14 @@ store_load(void) {
                store_oid = prev_oid;
 
        /* load remaining schemas, tables, columns etc */
+       tr->active = 1;
        if (!first && !load_trans(gtrans, id)) {
                GDKfree(store_oids);
                store_oids = NULL;
                nstore_oids = 0;
                return -1;
        }
+       tr->active = 0;
        store_initialized = 1;
        GDKfree(store_oids);
        store_oids = NULL;
@@ -2614,6 +2624,7 @@ idx_dup(sql_trans *tr, int flags, sql_id
                ni->base.allocated = i->base.allocated;
                ni->data = i->data;
                i->base.allocated = 0;
+               ni->base.wtime = i->base.wtime;
                i->data = NULL;
        } else
        if ((isNew(i) && newFlagSet(flags) && tr->parent == gtrans) ||
@@ -2838,6 +2849,7 @@ column_dup(sql_trans *tr, int flags, sql
                c->base.allocated = oc->base.allocated;
                c->data = oc->data;
                oc->base.allocated = 0;
+               c->base.wtime = oc->base.wtime;
                oc->data = NULL;
        } else 
        if ((isNew(oc) && newFlagSet(flags) && tr->parent == gtrans) ||
@@ -3042,6 +3054,7 @@ table_dup(sql_trans *tr, int flags, sql_
         * on savepoints from tr->parent to new tr */
        if (flags) {
                t->base.allocated = ot->base.allocated;
+               t->base.wtime = ot->base.wtime;
                t->data = ot->data;
                ot->base.allocated = 0;
                ot->data = NULL;
@@ -3299,6 +3312,7 @@ trans_init(sql_trans *tr, backend_stack 
 
                                t->base.rtime = t->base.wtime = 0;
                                t->base.stime = pt->base.wtime;
+                               assert(t->base.stime > 0 || !isTable(t));
                                if (!istmp && !t->base.allocated)
                                        t->data = NULL;
                                assert (istmp || !t->base.allocated);
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to