Changeset: 0290af71259b for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=0290af71259b
Modified Files:
        sql/include/sql_catalog.h
        sql/server/rel_distribute.c
        sql/server/rel_optimizer.c
        sql/server/rel_propagate.c
        sql/server/sql_partition.c
        sql/storage/bat/bat_storage.c
        sql/storage/sql_catalog.c
        sql/storage/store.c
Branch: nospare
Log Message:

cleanup more temp objects

use sqlid's for member field of sql_part, reduces need to create duplicated
tables on tables (member) changes


diffs (truncated from 385 to 300 lines):

diff --git a/sql/include/sql_catalog.h b/sql/include/sql_catalog.h
--- a/sql/include/sql_catalog.h
+++ b/sql/include/sql_catalog.h
@@ -655,13 +655,13 @@ typedef struct sql_part_value {
 
 typedef struct sql_part {
        sql_base base;
-       struct sql_table *t;      /* the merge table */
-       struct sql_table *member; /* the member of the merge table */
-       sql_subtype tpe;                  /* the column/expression type */
-       bit with_nills;                   /* 0 no nills, 1 holds nills, NULL 
holds all values -> range FROM MINVALUE TO MAXVALUE WITH NULL */
+       struct sql_table *t;    /* the merge table */
+       sqlid member;                   /* the member of the merge table */
+       sql_subtype tpe;                /* the column/expression type */
+       bit with_nills;                 /* 0 no nills, 1 holds nills, NULL 
holds all values -> range FROM MINVALUE TO MAXVALUE WITH NULL */
        union {
-               list *values;         /* partition by values/list */
-               struct sql_range {    /* partition by range */
+               list *values;       /* partition by values/list */
+               struct sql_range {  /* partition by range */
                        ptr minvalue;
                        ptr maxvalue;
                        size_t minlength;
diff --git a/sql/server/rel_distribute.c b/sql/server/rel_distribute.c
--- a/sql/server/rel_distribute.c
+++ b/sql/server/rel_distribute.c
@@ -81,7 +81,7 @@ static sql_rel *
 rewrite_replica( mvc *sql, sql_rel *rel, sql_table *t, sql_part *pd, int 
remote_prop)
 {
        node *n, *m;
-       sql_table *p = find_sql_table_id(sql->session->tr, t->s, 
pd->member->base.id);
+       sql_table *p = find_sql_table_id(sql->session->tr, t->s, pd->member);
        sql_rel *r = rel_basetable(sql, p, t->base.name);
 
        for (n = rel->exps->h, m = r->exps->h; n && m; n = n->next, m = 
m->next) {
@@ -197,7 +197,7 @@ replica(mvc *sql, sql_rel *rel, char *ur
                                /* replace by the replica which matches the uri 
*/
                                for (n = t->members.set->h; n; n = n->next) {
                                        sql_part *p = n->data;
-                                       sql_table *pt = 
find_sql_table_id(sql->session->tr, t->s, p->member->base.id);
+                                       sql_table *pt = 
find_sql_table_id(sql->session->tr, t->s, p->member);
 
                                        if (isRemote(pt) && strcmp(uri, 
pt->query) == 0) {
                                                rel = rewrite_replica(sql, rel, 
t, p, 0);
@@ -210,7 +210,7 @@ replica(mvc *sql, sql_rel *rel, char *ur
                                        sql_part *p;
                                        for (n = t->members.set->h; n; n = 
n->next) {
                                                sql_part *p = n->data;
-                                               sql_table *pt = 
find_sql_table_id(sql->session->tr, t->s, p->member->base.id);
+                                               sql_table *pt = 
find_sql_table_id(sql->session->tr, t->s, p->member);
 
                                                if (!isRemote(pt)) {
                                                        fnd = 1;
diff --git a/sql/server/rel_optimizer.c b/sql/server/rel_optimizer.c
--- a/sql/server/rel_optimizer.c
+++ b/sql/server/rel_optimizer.c
@@ -31,7 +31,7 @@ find_member_pos(list *l, sql_table *t)
        if (l) {
                for (node *n = l->h; n ; n = n->next, i++) {
                        sql_part *pt = n->data;
-                       if (pt->member->base.id == t->base.id)
+                       if (pt->member == t->base.id)
                                return i;
                }
        }
@@ -9007,7 +9007,7 @@ rel_merge_table_rewrite(visitor *v, sql_
 
                                        for (node *nt = t->members.set->h; nt; 
nt = nt->next) {
                                                sql_part *pd = nt->data;
-                                               sql_table *pt = 
find_sql_table_id(v->sql->session->tr, t->s, pd->member->base.id);
+                                               sql_table *pt = 
find_sql_table_id(v->sql->session->tr, t->s, pd->member);
                                                sql_rel *prel = 
rel_basetable(v->sql, pt, tname), *bt = NULL;
                                                int skip = 0;
                                                list *exps = NULL;
diff --git a/sql/server/rel_propagate.c b/sql/server/rel_propagate.c
--- a/sql/server/rel_propagate.c
+++ b/sql/server/rel_propagate.c
@@ -594,7 +594,7 @@ rel_generate_subdeletes(mvc *sql, sql_re
 
        for (node *n = t->members.set->h; n; n = n->next) {
                sql_part *pt = (sql_part *) n->data;
-               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member->base.id);
+               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member);
                sql_rel *s1, *dup = NULL;
 
                if (!update_allowed(sql, sub, sub->base.name, 
is_delete(rel->op) ? "DELETE": "TRUNCATE",
@@ -628,7 +628,7 @@ rel_generate_subupdates(mvc *sql, sql_re
 
        for (node *n = t->members.set->h; n; n = n->next) {
                sql_part *pt = (sql_part *) n->data;
-               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member->base.id);
+               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member);
                sql_rel *s1, *dup = NULL;
                list *uexps = exps_copy(sql, rel->exps), *checked_updates = 
new_exp_list(sql->sa);
 
@@ -696,7 +696,7 @@ rel_generate_subinserts(sql_query *query
 
        for (node *n = t->members.set->h; n; n = n->next) {
                sql_part *pt = (sql_part *) n->data;
-               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member->base.id);
+               sql_table *sub = find_sql_table_id(sql->session->tr, t->s, 
pt->member);
                sql_rel *s1 = NULL, *dup = NULL;
                sql_exp *le = NULL;
 
diff --git a/sql/server/sql_partition.c b/sql/server/sql_partition.c
--- a/sql/server/sql_partition.c
+++ b/sql/server/sql_partition.c
@@ -320,11 +320,11 @@ initialize_sql_parts(mvc *sql, sql_table
 
                for (node *n = mt->members.set->h; n; n = n->next) {
                        sql_part *next = (sql_part*) n->data, *p = 
SA_ZNEW(tr->sa, sql_part);
-                       sql_table *pt = find_sql_table_id(tr, mt->s, 
next->member->base.id);
+                       sql_table *pt = find_sql_table_id(tr, mt->s, 
next->member);
 
                        base_init(tr->sa, &p->base, next->base.id, TR_NEW, 
pt->base.name);
                        p->t = mt;
-                       p->member = pt;
+                       p->member = next->member;
                        assert(isMergeTable(mt) || isReplicaTable(mt));
                        p->tpe = found;
                        p->with_nills = next->with_nills;
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
@@ -2477,6 +2477,7 @@ tr_merge_dbat(sql_dbat *tdb)
 static sql_delta *
 savepoint_commit_delta( sql_delta *delta, ulng commit_ts)
 {
+       /* commit ie copy back to the parent transaction */
        if (delta && delta->ts == commit_ts && delta->next) {
                sql_delta *od = delta->next;
                if (od->ts == commit_ts) {
@@ -2796,7 +2797,7 @@ tc_gc_col( sql_store Store, sql_change *
                destroy_delta(d);
        }
 #endif
-       if (c->data != change->data) /* data is freed by commit */
+       if (c->data != change->data || isTempTable(c->t)) /* data is freed by 
commit */
                return 1;
        sql_delta *d = (sql_delta*)change->data;
        if (d->next) {
@@ -2834,7 +2835,7 @@ tc_gc_idx( sql_store Store, sql_change *
                destroy_delta(d);
        }
 #endif
-       if (i->data != change->data) /* data is freed by commit */
+       if (i->data != change->data || isTempTable(i->t)) /* data is freed by 
commit */
                return 1;
        sql_delta *d = (sql_delta*)change->data;
        if (d->next) {
@@ -2872,7 +2873,7 @@ tc_gc_del( sql_store Store, sql_change *
                destroy_dbat(d);
        }
 #endif
-       if (t->data != change->data) /* data is freed by commit */
+       if (t->data != change->data || isTempTable(t)) /* data is freed by 
commit */
                return 1;
        sql_dbat *d = (sql_dbat*)change->data;
        if (d->next) {
diff --git a/sql/storage/sql_catalog.c b/sql/storage/sql_catalog.c
--- a/sql/storage/sql_catalog.c
+++ b/sql/storage/sql_catalog.c
@@ -474,7 +474,7 @@ partition_find_part(sql_trans *tr, sql_t
                                pp = NULL;
                        continue;
                }
-               if (p->member->base.id == pt->base.id)
+               if (p->member == pt->base.id)
                        return p;
        }
        return NULL;
@@ -488,7 +488,7 @@ members_find_child_id(list *l, sqlid id)
                for (n = l->h; n; n = n->next) {
                        sql_part *p = n->data;
 
-                       if (id == p->member->base.id)
+                       if (id == p->member)
                                return n;
                }
        }
diff --git a/sql/storage/store.c b/sql/storage/store.c
--- a/sql/storage/store.c
+++ b/sql/storage/store.c
@@ -151,10 +151,6 @@ key_destroy(sqlstore *store, sql_key *k)
                return;
        list_destroy2(k->columns, store);
        k->columns = NULL;
-       /*
-       if ((k->type == pkey) && (k->t->pkey == (sql_ukey *) k))
-               k->t->pkey = NULL;
-               */
        _DELETE(k->base.name);
        _DELETE(k);
 }
@@ -518,7 +514,7 @@ load_range_partition(sql_trans *tr, sql_
        sqlstore *store = tr->store;
 
        pt->tpe = *empty;
-       rs = store->table_api.rids_select(tr, find_sql_column(ranges, 
"table_id"), &pt->member->base.id, &pt->member->base.id, NULL);
+       rs = store->table_api.rids_select(tr, find_sql_column(ranges, 
"table_id"), &pt->member, &pt->member, NULL);
        if ((rid = store->table_api.rids_next(rs)) != oid_nil) {
                void *v1, *v2, *v3;
                ValRecord vmin, vmax;
@@ -563,7 +559,7 @@ load_value_partition(sql_trans *tr, sql_
        sql_table *values = find_sql_table(tr, syss, "value_partitions");
        list *vals = NULL;
        oid rid;
-       rids *rs = store->table_api.rids_select(tr, find_sql_column(values, 
"table_id"), &pt->member->base.id, &pt->member->base.id, NULL);
+       rids *rs = store->table_api.rids_select(tr, find_sql_column(values, 
"table_id"), &pt->member, &pt->member, NULL);
        int i = 0;
        sql_subtype *empty = sql_bind_localtype("void");
 
@@ -616,7 +612,7 @@ load_part(sql_trans *tr, sql_table *mt, 
        sql_part *pt = SA_ZNEW(tr->sa, sql_part);
        sql_schema *syss = find_sql_schema(tr, "sys");
        sql_table *objects = find_sql_table(tr, syss, "objects");
-       sqlid id, childid;
+       sqlid id;
        sqlstore *store = tr->store;
 
        assert(isMergeTable(mt) || isReplicaTable(mt));
@@ -625,11 +621,8 @@ load_part(sql_trans *tr, sql_table *mt, 
        v = store->table_api.column_find_value(tr, find_sql_column(objects, 
"name"), rid);
        base_init(tr->sa, &pt->base, id, 0, v); _DELETE(v);
        v = store->table_api.column_find_value(tr, find_sql_column(objects, 
"sub"), rid);
-       childid = *(sqlid*)v; _DELETE(v);
-       sql_table *member = find_sql_table_id(tr, mt->s, childid);
-       assert(member);
        pt->t = mt;
-       pt->member = member;
+       pt->member = *(sqlid*)v; _DELETE(v);
        cs_add(&mt->members, pt, 0);
        return pt;
 }
@@ -1072,7 +1065,7 @@ load_schema(sql_trans *tr, sqlid id, oid
                s->keys = os_new(tr->sa, (destroy_fptr) &key_destroy, false, 
true);
                s->idxs = os_new(tr->sa, (destroy_fptr) &idx_destroy, false, 
true);
                s->triggers = os_new(tr->sa, (destroy_fptr) &trigger_destroy, 
false, true);
-               s->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, false, 
true);
+               s->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, false, 
false);
        }
 
        TRC_DEBUG(SQL_STORE, "Load schema: %s %d\n", s->base.name, s->base.id);
@@ -1672,7 +1665,7 @@ bootstrap_create_schema(sql_trans *tr, c
        s->keys = os_new(tr->sa, (destroy_fptr) &key_destroy, false, true);
        s->idxs = os_new(tr->sa, (destroy_fptr) &idx_destroy, false, true);
        s->triggers = os_new(tr->sa, (destroy_fptr) &trigger_destroy, false, 
true);
-       s->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, false, true);
+       s->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, false, false);
        if (os_add(tr->cat->schemas, tr, s->base.name, &s->base)) {
                schema_destroy(store, s);
                return NULL;
@@ -2919,15 +2912,13 @@ part_dup(sql_trans *tr, sql_part *op, sq
 {
        sql_allocator *sa = tr->sa;
        sql_part *p = SA_ZNEW(sa, sql_part);
-       sql_table *member = find_sql_table_id(tr, mt->s, op->member->base.id);
-
-       assert(member);
+
        assert(isMergeTable(mt) || isReplicaTable(mt));
        base_init(sa, &p->base, op->base.id, 0, op->base.name);
        p->tpe = op->tpe;
        p->with_nills = op->with_nills;
        p->t = mt;
-       p->member = member;
+       p->member = op->member;
 
        if (isRangePartitionTable(mt)) {
                p->part.range.minvalue = SA_NEW_ARRAY(sa, char, 
op->part.range.minlength);
@@ -3510,7 +3501,7 @@ schema_dup(sql_trans *tr, sql_schema *s)
        ns->keys = os_new(tr->sa, (destroy_fptr) &key_destroy, isTempSchema(s), 
true);
        ns->idxs = os_new(tr->sa, (destroy_fptr) &idx_destroy, isTempSchema(s), 
true);
        ns->triggers = os_new(tr->sa, (destroy_fptr) &trigger_destroy, 
isTempSchema(s), true);
-       ns->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, 
isTempSchema(s), true);
+       ns->parts = os_new(tr->sa, (destroy_fptr) &part_destroy, 
isTempSchema(s), false);
 
        /* table_dup will dup keys, idxs, triggers and parts */
        struct os_iter oi;
@@ -3564,6 +3555,18 @@ sql_trans_commit(sql_trans *tr)
                tr->localtmps.nelm = NULL;
        }
        TRC_DEBUG(SQL_STORE, "Forwarding changes (" ULLFMT ", " ULLFMT ") -> " 
ULLFMT "\n", tr->tid, tr->ts, commit_ts);
+       if (!list_empty(store->changes)) { /* lets first cleanup old stuff */
+               for(node *n=store->changes->h; n; ) {
+                       node *next = n->next;
+                       sql_change *c = n->data;
+
+                       if (c->cleanup && c->cleanup(store, c, commit_ts, 
oldest)) {
+                               list_remove_node(store->changes, store, n);
+                               _DELETE(c);
+                       }
+                       n = next;
+               }
+       }
        if (tr->changes) {
                /* log changes should only be done if there is something to log 
*/
                if (tr->logchanges > 0) {
@@ -3596,7 +3599,10 @@ sql_trans_commit(sql_trans *tr)
                for(node *n=tr->changes->h; n && ok == LOG_OK; ) {
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to