Changeset: 7fe1b90e04d2 for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=7fe1b90e04d2
Modified Files:
sql/include/sql_catalog.h
sql/storage/objectset.c
sql/storage/store.c
Branch: nospare
Log Message:
more clean object dup's for the table and lower objects
added faster iterator for name based lookups (mostly for functions)
diffs (truncated from 685 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
@@ -11,6 +11,7 @@
#include "sql_mem.h"
#include "sql_list.h"
+#include "sql_hash.h"
#include "mapi_querytype.h"
#include "stream.h"
@@ -227,6 +228,7 @@ struct os_iter {
struct objectset *os;
struct sql_trans *tr;
struct object_node *n;
+ struct sql_hash_e *e;
const char *name;
};
diff --git a/sql/storage/objectset.c b/sql/storage/objectset.c
--- a/sql/storage/objectset.c
+++ b/sql/storage/objectset.c
@@ -356,6 +356,38 @@ os_name_key(object_node *n)
return hash_key(n->data->obj->name);
}
+static sql_hash*
+os_hash_create(objectset *os)
+{
+ MT_lock_set(&os->ht_lock);
+ if ((!os->name_map || os->name_map->size*16 < os->cnt) && os->sa) {
+ os->name_map = hash_new(os->sa, os->cnt,
(fkeyvalue)&os_name_key);
+ if (os->name_map == NULL) {
+ MT_lock_unset(&os->ht_lock);
+ return NULL;
+ }
+
+ for (object_node *n = os->h; n; n = n->next ) {
+ int key = os_name_key(n);
+ if (hash_add(os->name_map, key, n) == NULL) {
+ MT_lock_unset(&os->ht_lock);
+ return NULL;
+ }
+ }
+ }
+ MT_lock_unset(&os->ht_lock);
+ return os->name_map;
+}
+
+static sql_hash_e *
+find_hash_entry(sql_hash *map, const char *name)
+{
+ int key = hash_key(name);
+ sql_hash_e *he = map->buckets[key&(map->size-1)];
+
+ return he;
+}
+
static object_node *
find_name(objectset *os, const char *name)
{
@@ -591,23 +623,48 @@ os_iterator(struct os_iter *oi, struct o
.os = os,
.tr = tr,
.name = name,
- .n = /* name ? find_name(os, name) : */ os->h,
};
+ if (os->cnt && name) {
+ if (!os->name_map)
+ os->name_map = os_hash_create(os);
+ oi->e = find_hash_entry(os->name_map, name);
+ } else
+ oi->n = os->h;
}
sql_base *
oi_next(struct os_iter *oi)
{
- object_node *n = oi->n;
sql_base *b = NULL;
- while (n && !b) {
- objectversion *ov = n->data;
- n = oi->n = n->next;
+ if (oi->name) {
+ sql_hash_e *e = oi->e;
+
+ while (e && !b) {
+ object_node *n = e->value;
+
+ if (n && n->data->obj->name &&
strcmp(n->data->obj->name, oi->name) == 0) {
+ objectversion *ov = n->data;
+ e = oi->e = e->chain;
- ov = get_valid_object(oi->tr, ov);
- if (ov)
- b = ov->obj;
+ ov = get_valid_object(oi->tr, ov);
+ if (ov)
+ b = ov->obj;
+ } else {
+ e = e->chain;
+ }
+ }
+ } else {
+ object_node *n = oi->n;
+
+ while (n && !b) {
+ objectversion *ov = n->data;
+ n = oi->n = n->next;
+
+ ov = get_valid_object(oi->tr, ov);
+ if (ov)
+ b = ov->obj;
+ }
}
return b;
}
diff --git a/sql/storage/store.c b/sql/storage/store.c
--- a/sql/storage/store.c
+++ b/sql/storage/store.c
@@ -2576,8 +2576,39 @@ end:
return result;
}
+static sql_column *
+column_dup(sql_trans *tr, sql_column *oc, sql_table *t)
+{
+ sqlstore *store = tr->store;
+ sql_allocator *sa = tr->sa;
+ sql_column *c = SA_ZNEW(sa, sql_column);
+
+ base_init(sa, &c->base, oc->base.id, 0, oc->base.name);
+ c->type = oc->type;
+ c->def = NULL;
+ if (oc->def)
+ c->def = sa_strdup(sa, oc->def);
+ c->null = oc->null;
+ c->colnr = oc->colnr;
+ c->unique = oc->unique;
+ c->t = t;
+ c->storage_type = NULL;
+ if (oc->storage_type)
+ c->storage_type = sa_strdup(sa, oc->storage_type);
+
+ if (isTable(c->t)) {
+ if (isTempTable(c->t)) {
+ if (store->storage_api.create_col(tr, c) != LOG_OK)
+ return NULL;
+ } else {
+ c->data = store->storage_api.col_dup(oc);
+ }
+ }
+ return c;
+}
+
static sql_kc *
-kc_dup_(sql_trans *tr, sql_kc *kc, sql_table *t)
+kc_dup(sql_trans *tr, sql_kc *kc, sql_table *t)
{
sql_allocator *sa = tr->sa;
sql_kc *nkc = SA_ZNEW(sa, sql_kc);
@@ -2589,25 +2620,15 @@ kc_dup_(sql_trans *tr, sql_kc *kc, sql_t
return nkc;
}
-static int
-tr_flag(sql_base * b, int flags)
-{
- if (!newFlagSet(flags))
- return flags;
- return b->flags;
-}
-
static sql_key *
-key_dup_(sql_trans *tr, int flags, sql_key *k, sql_table *t, int copy)
+key_dup(sql_trans *tr, sql_key *k, sql_table *t)
{
sql_allocator *sa = tr->sa;
sql_key *nk = (k->type != fkey) ? (sql_key *) SA_ZNEW(sa, sql_ukey)
: (sql_key *) SA_ZNEW(sa, sql_fkey);
node *n;
- assert(k->base.id || copy);
- base_init(sa, &nk->base, k->base.id?k->base.id:next_oid(tr->store),
tr_flag(&k->base, flags), k->base.name);
-
+ base_init(sa, &nk->base, k->base.id?k->base.id:next_oid(tr->store), 0,
k->base.name);
nk->type = k->type;
nk->columns = list_new(sa, (fdestroy) NULL);
nk->t = t;
@@ -2639,61 +2660,128 @@ key_dup_(sql_trans *tr, int flags, sql_k
for (n = k->columns->h; n; n = n->next) {
sql_kc *okc = n->data;
- list_append(nk->columns, kc_dup_(tr, okc, t));
+ list_append(nk->columns, kc_dup(tr, okc, t));
}
if (os_add(t->s->keys, tr, nk->base.name, &nk->base))
return NULL;
- if (!copy && newFlagSet(flags)/* && tr->parent == gtrans*/)
- removeNewFlag(k);
return nk;
}
-static sql_column *
-column_dup(sql_trans *tr, sql_column *oc, sql_table *t, int deep)
+
+static sql_idx *
+idx_dup(sql_trans *tr, sql_idx * i, sql_table *t)
{
sqlstore *store = tr->store;
sql_allocator *sa = tr->sa;
- sql_column *c = SA_ZNEW(sa, sql_column);
-
- base_init(sa, &c->base, oc->base.id, 0, oc->base.name);
- c->type = oc->type;
- c->def = NULL;
- if (oc->def)
- c->def = sa_strdup(sa, oc->def);
- c->null = oc->null;
- c->colnr = oc->colnr;
- c->unique = oc->unique;
- c->t = t;
- c->storage_type = NULL;
- if (oc->storage_type)
- c->storage_type = sa_strdup(sa, oc->storage_type);
-
- if (isTable(c->t)) {
- if (deep)
- store->storage_api.create_col(tr, c);
- else
- c->data = store->storage_api.col_dup(oc);
- }
- return c;
-}
-
-static sql_base *
-base_incref(sql_base *b)
-{
- b->refcnt++;
- return b;
+ sql_idx *ni = SA_ZNEW(sa, sql_idx);
+ node *n;
+
+ base_init(sa, &ni->base, i->base.id, 0, i->base.name);
+
+ ni->columns = list_new(sa, (fdestroy) NULL);
+ ni->t = t;
+ ni->type = i->type;
+ ni->key = NULL;
+
+ if (isTable(i->t)) {
+ if (isTempTable(i->t)) {
+ if (store->storage_api.create_idx(tr, ni) != LOG_OK)
+ return NULL;
+ } else {
+ ni->data = store->storage_api.idx_dup(i);
+ }
+ }
+
+ for (n = i->columns->h; n; n = n->next) {
+ sql_kc *okc = n->data;
+
+ list_append(ni->columns, kc_dup(tr, okc, t));
+ }
+ if (os_add(t->s->idxs, tr, ni->base.name, &ni->base))
+ return NULL;
+ return ni;
+}
+
+static sql_part *
+part_dup(sql_trans *tr, sql_part *op, sql_table *mt)
+{
+ sql_allocator *sa = tr->sa;
+ sql_part *p = SA_ZNEW(sa, sql_part);
+ sql_table *member = find_sql_table_id(tr, mt->s, op->base.id);
+
+ base_init(sa, &p->base, op->base.id, 0, op->base.name);
+ p->tpe = op->tpe;
+ p->with_nills = op->with_nills;
+ assert(isMergeTable(mt) || isReplicaTable(mt));
+ p->t = mt;
+ assert(member);
+ p->member = member;
+ member->partition++; /* todo remove */
+
+ if (isRangePartitionTable(mt)) {
+ p->part.range.minvalue = sa_alloc(sa, op->part.range.minlength);
+ p->part.range.maxvalue = sa_alloc(sa, op->part.range.maxlength);
+ memcpy(p->part.range.minvalue, op->part.range.minvalue,
op->part.range.minlength);
+ memcpy(p->part.range.maxvalue, op->part.range.maxvalue,
op->part.range.maxlength);
+ p->part.range.minlength = op->part.range.minlength;
+ p->part.range.maxlength = op->part.range.maxlength;
+ } else if (isListPartitionTable(mt)) {
+ p->part.values = list_new(sa, (fdestroy) NULL);
+ for (node *n = op->part.values->h ; n ; n = n->next) {
+ sql_part_value *prev = (sql_part_value*) n->data,
*nextv = SA_ZNEW(sa, sql_part_value);
+ nextv->value = sa_alloc(sa, prev->length);
+ memcpy(nextv->value, prev->value, prev->length);
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
