Changeset: 6f4d6848910f for MonetDB
URL: https://dev.monetdb.org/hg/MonetDB/rev/6f4d6848910f
Modified Files:
        sql/server/rel_statistics.c
        sql/server/sql_mvc.c
        sql/server/sql_mvc.h
        sql/storage/bat/bat_storage.c
        sql/storage/sql_storage.h
        sql/storage/store.c
Branch: properties
Log Message:

Pack bat storage calls for properties into one, because later new properties 
may be introduced


diffs (291 lines):

diff --git a/sql/server/rel_statistics.c b/sql/server/rel_statistics.c
--- a/sql/server/rel_statistics.c
+++ b/sql/server/rel_statistics.c
@@ -204,26 +204,25 @@ rel_basetable_get_statistics(visitor *v,
 
        (void)depth;
        if ((c = name_find_column(rel, exp_relname(e), exp_name(e), -2, NULL))) 
{
+               bool nonil = false;
                ValRecord min, max;
-
-               if (has_nil(e) && mvc_has_no_nil(sql, c))
-                       set_has_no_nil(e);
+               int ok = mvc_col_stats(sql, c, &nonil, &min, &max);
 
-               if (EC_NUMBER(c->type.type->eclass) || 
EC_VARCHAR(c->type.type->eclass) || EC_TEMP_NOFRAC(c->type.type->eclass) || 
c->type.type->eclass == EC_DATE) {
-                       if (mvc_has_max_value(sql, c, &max)) {
-                               if (!VALisnil(&max)) {
-                                       prop *p = e->p = prop_create(sql->sa, 
PROP_MAX, e->p);
-                                       p->value = atom_from_valptr(sql->sa, 
&c->type, &max);
-                               }
-                               VALclear(&max);
+               if (has_nil(e) && nonil)
+                       set_has_no_nil(e);
+               if ((ok & 1) == 1) {
+                       if (!VALisnil(&min)) {
+                               prop *p = e->p = prop_create(sql->sa, PROP_MIN, 
e->p);
+                               p->value = atom_from_valptr(sql->sa, &c->type, 
&min);
                        }
-                       if (mvc_has_min_value(sql, c, &min)) {
-                               if (!VALisnil(&min)) {
-                                       prop *p = e->p = prop_create(sql->sa, 
PROP_MIN, e->p);
-                                       p->value = atom_from_valptr(sql->sa, 
&c->type, &min);
-                               }
-                               VALclear(&min);
+                       VALclear(&min);
+               }
+               if ((ok & 2) == 2) {
+                       if (!VALisnil(&max)) {
+                               prop *p = e->p = prop_create(sql->sa, PROP_MAX, 
e->p);
+                               p->value = atom_from_valptr(sql->sa, &c->type, 
&max);
                        }
+                       VALclear(&max);
                }
        }
        return e;
diff --git a/sql/server/sql_mvc.c b/sql/server/sql_mvc.c
--- a/sql/server/sql_mvc.c
+++ b/sql/server/sql_mvc.c
@@ -1541,24 +1541,10 @@ mvc_is_duplicate_eliminated(mvc *m, sql_
 }
 
 int
-mvc_has_no_nil(mvc *m, sql_column *col)
-{
-       TRC_DEBUG(SQL_TRANS, "Has no null values: %s\n", col->base.name);
-       return sql_trans_no_nil(m->session->tr, col);
-}
-
-int
-mvc_has_min_value(mvc *m, sql_column *col, ValPtr res)
+mvc_col_stats(mvc *m, sql_column *col, bool *nonil, ValPtr min, ValPtr max)
 {
-       TRC_DEBUG(SQL_TRANS, "Has min value: %s\n", col->base.name);
-       return sql_trans_col_min_value(m->session->tr, col, res);
-}
-
-int
-mvc_has_max_value(mvc *m, sql_column *col, ValPtr res)
-{
-       TRC_DEBUG(SQL_TRANS, "Has max value: %s\n", col->base.name);
-       return sql_trans_col_max_value(m->session->tr, col, res);
+       TRC_DEBUG(SQL_TRANS, "Retrieving column stats for: %s\n", 
col->base.name);
+       return sql_trans_col_stats(m->session->tr, col, nonil, min, max);
 }
 
 int
diff --git a/sql/server/sql_mvc.h b/sql/server/sql_mvc.h
--- a/sql/server/sql_mvc.h
+++ b/sql/server/sql_mvc.h
@@ -218,9 +218,7 @@ extern int mvc_access(mvc *m, sql_table 
 extern int mvc_is_sorted(mvc *c, sql_column *col);
 extern int mvc_is_unique(mvc *m, sql_column *col);
 extern int mvc_is_duplicate_eliminated(mvc *c, sql_column *col);
-extern int mvc_has_no_nil(mvc *m, sql_column *col);
-extern int mvc_has_min_value(mvc *m, sql_column *col, ValPtr res);
-extern int mvc_has_max_value(mvc *m, sql_column *col, ValPtr res);
+extern int mvc_col_stats(mvc *m, sql_column *col, bool *nonil, ValPtr min, 
ValPtr max);
 
 extern int mvc_create_ukey(sql_key **kres, mvc *m, sql_table *t, const char 
*name, key_type kt);
 extern int mvc_create_fkey(sql_fkey **kres, mvc *m, sql_table *t, const char 
*name, key_type kt, sql_key *rkey, int on_delete, int on_update);
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
@@ -2705,90 +2705,40 @@ double_elim_col(sql_trans *tr, sql_colum
 }
 
 static int
-nonil_col(sql_trans *tr, sql_column *col)
-{
-       int nonil = 0;
-       BAT *b = NULL;
-       sql_delta *d = NULL;
-
-       assert(tr->active);
-       if (!col || !isTable(col->t) || !col->t->s)
-               return 0;
-
-       if ((d = ATOMIC_PTR_GET(&col->data)) && (b = 
quick_descriptor(d->cs.bid))) {
-               nonil = b->tnonil && !b->tnil;
-
-               if (nonil && d->cs.ucnt > 0) {
-                       if (!(b = quick_descriptor(d->cs.uvbid)))
-                               return 0;
-                       nonil &= b->tnonil && !b->tnil;
-               }
-       }
-       return nonil;
-}
-
-static int
-col_min_value(sql_trans *tr, sql_column *c, ValPtr res)
+col_stats(sql_trans *tr, sql_column *c, bool *nonil, ValPtr min, ValPtr max)
 {
        int ok = 0;
        BAT *b = NULL;
        sql_delta *d = NULL;
 
        assert(tr->active);
+       *nonil = false;
        if (!c || !isTable(c->t) || !c->t->s)
-               return 0;
-
-       if (c->storage_type) {
-               if ((d = ATOMIC_PTR_GET(&c->data)) && d->cs.st == ST_DICT && 
d->cs.ucnt == 0 &&
-                       (b = temp_descriptor(d->cs.ebid))) {
-                       BATiter bi = bat_iterator(b);
-                       if (bi.minpos != BUN_NONE && VALinit(res, bi.type, 
BUNtail(bi, bi.minpos)))
-                               ok = 1;
-                       bat_iterator_end(&bi);
-                       bat_destroy(b);
-               }
                return ok;
-       }
-       if ((d = ATOMIC_PTR_GET(&c->data)) && d->cs.ucnt == 0 && (b = 
quick_descriptor(d->cs.bid)) &&
-               b->tminpos != BUN_NONE && (b = temp_descriptor(d->cs.bid))) {
-               BATiter bi = bat_iterator(b);
-               if (bi.minpos != BUN_NONE && VALinit(res, bi.type, BUNtail(bi, 
bi.minpos)))
-                       ok = 1;
-               bat_iterator_end(&bi);
-               bat_destroy(b);
-       }
-       return ok;
-}
-
-static int
-col_max_value(sql_trans *tr, sql_column *c, ValPtr res)
-{
-       int ok = 0;
-       BAT *b = NULL;
-       sql_delta *d = NULL;
-
-       assert(tr->active);
-       if (!c || !isTable(c->t) || !c->t->s)
-               return 0;
-
-       if (c->storage_type) {
-               if ((d = ATOMIC_PTR_GET(&c->data)) && d->cs.st == ST_DICT && 
d->cs.ucnt == 0 &&
-                       (b = temp_descriptor(d->cs.ebid))) {
-                       BATiter bi = bat_iterator(b);
-                       if (bi.maxpos != BUN_NONE && VALinit(res, bi.type, 
BUNtail(bi, bi.maxpos)))
-                               ok = 1;
-                       bat_iterator_end(&bi);
-                       bat_destroy(b);
+
+       if ((d = ATOMIC_PTR_GET(&c->data))) {
+               if (d->cs.st == ST_FOR) {
+                       *nonil = true; /* TODO for min/max. I will do it later 
*/
+                       return ok;
                }
-               return ok;
-       }
-       if ((d = ATOMIC_PTR_GET(&c->data)) && d->cs.ucnt == 0 && (b = 
quick_descriptor(d->cs.bid)) &&
-               b->tmaxpos != BUN_NONE && (b = temp_descriptor(d->cs.bid))) {
-               BATiter bi = bat_iterator(b);
-               if (bi.maxpos != BUN_NONE && VALinit(res, bi.type, BUNtail(bi, 
bi.maxpos)))
-                       ok = 1;
-               bat_iterator_end(&bi);
-               bat_destroy(b);
+               bat bid = d->cs.st == ST_DICT ? d->cs.ebid : d->cs.bid;
+               if ((b = quick_descriptor(bid))) {
+                       *nonil = b->tnonil && !b->tnil;
+                       int eclass = c->type.type->eclass;
+
+                       if ((EC_NUMBER(eclass) || EC_VARCHAR(eclass) || 
EC_TEMP_NOFRAC(eclass) || eclass == EC_DATE) &&
+                               d->cs.ucnt == 0 && (b->tminpos != BUN_NONE || 
b->tmaxpos != BUN_NONE) && (b = temp_descriptor(bid))) {
+                               BATiter bi = bat_iterator(b);
+                               if (bi.minpos != BUN_NONE && VALinit(min, 
bi.type, BUNtail(bi, bi.minpos)))
+                                       ok |= 1;
+                               if (bi.maxpos != BUN_NONE && VALinit(max, 
bi.type, BUNtail(bi, bi.maxpos)))
+                                       ok |= 2;
+                               bat_iterator_end(&bi);
+                               bat_destroy(b);
+                       }
+                       if (*nonil && d->cs.ucnt > 0)
+                               *nonil &= ((b = quick_descriptor(d->cs.uvbid)) 
!= NULL) && b->tnonil && !b->tnil;
+               }
        }
        return ok;
 }
@@ -4840,9 +4790,7 @@ bat_storage_init( store_functions *sf)
        sf->sorted_col = &sorted_col;
        sf->unique_col = &unique_col;
        sf->double_elim_col = &double_elim_col;
-       sf->nonil_col = &nonil_col;
-       sf->col_min_value = &col_min_value;
-       sf->col_max_value = &col_max_value;
+       sf->col_stats = &col_stats;
 
        sf->col_dup = &col_dup;
        sf->idx_dup = &idx_dup;
diff --git a/sql/storage/sql_storage.h b/sql/storage/sql_storage.h
--- a/sql/storage/sql_storage.h
+++ b/sql/storage/sql_storage.h
@@ -154,7 +154,7 @@ typedef size_t (*count_idx_fptr) (sql_tr
 typedef size_t (*dcount_col_fptr) (sql_trans *tr, sql_column *c);
 typedef int (*min_max_col_fptr) (sql_trans *tr, sql_column *c);
 typedef int (*prop_col_fptr) (sql_trans *tr, sql_column *c);
-typedef int (*proprec_col_fptr) (sql_trans *tr, sql_column *c, ValPtr res);
+typedef int (*proprec_col_fptr) (sql_trans *tr, sql_column *c, bool *nonil, 
ValPtr min, ValPtr max);
 
 /*
 -- create the necessary storage resources for columns, indices and tables
@@ -240,9 +240,7 @@ typedef struct store_functions {
        prop_col_fptr sorted_col;
        prop_col_fptr unique_col;
        prop_col_fptr double_elim_col; /* varsize col with double elimination */
-       prop_col_fptr nonil_col;
-       proprec_col_fptr col_min_value;
-       proprec_col_fptr col_max_value;
+       proprec_col_fptr col_stats;
 
        col_dup_fptr col_dup;
        idx_dup_fptr idx_dup;
@@ -398,10 +396,8 @@ extern int sql_trans_alter_storage(sql_t
 extern int sql_trans_is_sorted(sql_trans *tr, sql_column *col);
 extern int sql_trans_is_unique(sql_trans *tr, sql_column *col);
 extern int sql_trans_is_duplicate_eliminated(sql_trans *tr, sql_column *col);
-extern int sql_trans_no_nil(sql_trans *tr, sql_column *col);
+extern int sql_trans_col_stats(sql_trans *tr, sql_column *col, bool *nonil, 
ValPtr min, ValPtr max);
 extern size_t sql_trans_dist_count(sql_trans *tr, sql_column *col);
-extern int sql_trans_col_min_value(sql_trans *tr, sql_column *col, ValPtr res);
-extern int sql_trans_col_max_value(sql_trans *tr, sql_column *col, ValPtr res);
 extern int sql_trans_ranges(sql_trans *tr, sql_column *col, void **min, void 
**max);
 
 extern void column_destroy(struct sqlstore *store, sql_column *c);
diff --git a/sql/storage/store.c b/sql/storage/store.c
--- a/sql/storage/store.c
+++ b/sql/storage/store.c
@@ -6173,29 +6173,11 @@ sql_trans_is_duplicate_eliminated( sql_t
 }
 
 int
-sql_trans_no_nil( sql_trans *tr, sql_column *col )
-{
-       sqlstore *store = tr->store;
-       if (col && isTable(col->t) && store->storage_api.nonil_col)
-               return store->storage_api.nonil_col(tr, col);
-       return 0;
-}
-
-int
-sql_trans_col_min_value( sql_trans *tr, sql_column *col, ValPtr res)
+sql_trans_col_stats( sql_trans *tr, sql_column *col, bool *nonil, ValPtr min, 
ValPtr max )
 {
        sqlstore *store = tr->store;
-       if (col && isTable(col->t) && store->storage_api.col_min_value)
-               return store->storage_api.col_min_value(tr, col, res);
-       return 0;
-}
-
-int
-sql_trans_col_max_value( sql_trans *tr, sql_column *col, ValPtr res)
-{
-       sqlstore *store = tr->store;
-       if (col && isTable(col->t) && store->storage_api.col_max_value)
-               return store->storage_api.col_max_value(tr, col, res);
+       if (col && isTable(col->t) && store->storage_api.col_stats)
+               return store->storage_api.col_stats(tr, col, nonil, min, max);
        return 0;
 }
 
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list

Reply via email to