Changeset: c8295f0f5f82 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=c8295f0f5f82
Modified Files:
sql/include/sql_catalog.h
sql/server/rel_schema.c
sql/server/sql_mvc.c
sql/server/sql_mvc.h
sql/storage/sql_storage.h
sql/storage/store.c
Branch: arrays
Log Message:
min, max, step made char* and treated similar to default value in columns
_dimensions table created and updated in catalog
diffs (truncated from 668 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
@@ -452,16 +452,10 @@ typedef struct sql_column {
void *data;
} sql_column;
-//dimension needs atom. Since is stores pointers to atom there is no
-//need to find the type. The important is to know that there is a
-//type atom
-typedef struct atom atom;
-
typedef struct sql_dimension {
sql_base base;
sql_subtype type;
int dimnr; //the order of the dimension
- char *def; //I think this is for default values
char *storage_type;
size_t dcount; /* what does it do? */
@@ -473,13 +467,14 @@ typedef struct sql_dimension {
//the exact type is found through the type field of the struct
//Niels said to use atom. In this case do I need the information about
the type?
//maybe I need to to check that the values when inserting a new cell
are of the correct type
- atom *min;
- atom *step;
- atom *max;
-
+ char *min;
+ char *step;
+ char *max;
+ char *def; //default value
+
lng lvl1_repeatsNum; //number of times each value of the dimension is
repeated before being increased
lng lvl2_repeatsNum; //number of times all values of the dimension are
repeated as a group (including the duplicated values defined by repeatNum)
- lng elementsNum; //the distinct number of elements in this dimension,
i.e. the nu,ber of indices
+ lng elementsNum; //the distinct number of elements in this dimension,
i.e. the number of indices
struct sql_table *t;
// void *data; //it does not have data since it is not materialised
diff --git a/sql/server/rel_schema.c b/sql/server/rel_schema.c
--- a/sql/server/rel_schema.c
+++ b/sql/server/rel_schema.c
@@ -433,6 +433,117 @@ column_options(mvc *sql, dlist *opt_list
return SQL_OK;
}
+static int dimension_range(mvc *sql, symbol *range, sql_dimension* dim) {
+ char *err = NULL;
+ char *r = NULL;
+
+ switch(dlist_length(range->data.lval)) {
+ case 0:
+ dim->unbounded_min = 1;
+ dim->unbounded_max = 1;
+
+ dim->min = NULL;
+ dim->step = NULL;
+ dim->max = NULL;
+ break;
+ case 1: {
+ char *min = "0";
+ char *step = "1";
+ dim->min = min;
+ dim->step = step;
+ r = symbol2string(sql, range->data.lval->h->data.sym, &err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect max value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else {
+ int m = atoi(r) - 1;
+ sprintf(r, "%d", m);
+ dim->max = r;
+ }
+ break;
+ }
+ case 2:
+ dim->unbounded_max = 1;
+ r = symbol2string(sql, range->data.lval->h->data.sym, &err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect min value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else
+ dim->min = r;
+ r = symbol2string(sql, range->data.lval->h->next->data.sym,
&err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect step value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else
+ dim->step = r;
+ dim->max = NULL;
+ break;
+ case 3:
+ r = symbol2string(sql, range->data.lval->h->data.sym, &err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect min value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else
+ dim->min = r;
+ r = symbol2string(sql, range->data.lval->h->next->data.sym,
&err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect step value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else
+ dim->step = r;
+ r = symbol2string(sql, range->data.lval->h->next->next->data.sym,
&err);
+ if (!r) {
+ (void) sql_error(sql, 02, "42000!incorrect max value
'%s'\n", err?err:"");
+ if (err) _DELETE(err);
+ return SQL_ERR;
+ } else
+ dim->max = r;
+ break;
+ }
+#if 0
+ if(!dim->unbounded_min && !dim->unbounded_max) {
+ switch(dim->type->localtype) {
+ case TYPE_bte:
+ dim->elementsNum = floor((dim->max->data.val.btval -
dim->min->data.val.btval )/ dim->step->data.val.btval)+1;
+ break;
+ case TYPE_sht:
+ dim->elementsNum = floor((dim->max->data.val.shval -
dim->min->data.val.shval )/ dim->step->data.val.shval)+1;
+ break;
+ case TYPE_int:
+ dim->elementsNum = floor((dim->max->data.val.ival -
dim->min->data.val.ival )/ dim->step->data.val.ival)+1;
+ break;
+ case TYPE_wrd:
+ dim->elementsNum = floor((dim->max->data.val.wval -
dim->min->data.val.wval )/ dim->step->data.val.wval)+1;
+ break;
+ case TYPE_oid:
+ dim->elementsNum = floor((dim->max->data.val.oval -
dim->min->data.val.oval )/ dim->step->data.val.oval)+1;
+ break;
+ case TYPE_lng:
+ dim->elementsNum = floor((dim->max->data.val.lval -
dim->min->data.val.lval )/ dim->step->data.val.lval)+1;
+ break;
+ case TYPE_dbl:
+ dim->elementsNum = floor((dim->max->data.val.dval -
dim->min->data.val.dval )/ dim->step->data.val.dval)+1;
+ break;
+ case TYPE_flt:
+ dim->elementsNum = floor((dim->max->data.val.fval -
dim->min->data.val.fval )/ dim->step->data.val.fval)+1;
+ break;
+ default:
+ fprintf(stderr, "Dimension of unknown type");
+ return NULL;
+ }
+ }
+ else
+ dim->elementsNum = 0; //unbounded does not have elements. It should be
checked and updated at each insertion
+#endif
+ return SQL_OK;
+}
+
+
static int
table_foreign_key(mvc *sql, char *name, symbol *s, sql_schema *ss, sql_table
*t)
{
@@ -574,7 +685,6 @@ create_dimension(mvc *sql, symbol *s, sq
char *dname = l->h->data.sval;
sql_subtype *dtype = &l->h->next->data.typeval;
symbol *ranges_sym = l->h->next->next->data.sym;
- list *range = sa_list(sql->sa);
(void)ss;
@@ -582,7 +692,6 @@ create_dimension(mvc *sql, symbol *s, sq
if (dname && dtype) {
sql_dimension *dim = NULL;
- dnode *range_value = NULL;
dim = find_sql_dimension(t, dname); //check whether the name
has already been used
if (dim) {
@@ -598,20 +707,9 @@ create_dimension(mvc *sql, symbol *s, sq
}
}
- for(range_value = ranges_sym->data.lval->h ; range_value ;
range_value = range_value->next) {
- atom *val = NULL;
-
- assert(range_value->data.sym->token == SQL_COLUMN);
- val = sql_bind_arg(sql,
range_value->data.sym->data.lval->h->data.i_val);
+ dim = mvc_create_dimension(sql, t, dname, dtype);
- //check whether the type of the value for the range is
compatible with the type of the dimension
- //I do not do any casting here, just making sure that
the types are compatible
- if(!rel_check_type(sql, dtype, exp_atom(sql->sa, val),
type_cast))
- return SQL_ERR;
- list_append(range, val);
- }
-
- dim = mvc_create_dimension(sql, t, dname, dtype, range);
+ dimension_range(sql, l->h->next->next->data.sym, dim);
}
return SQL_OK;
}
@@ -926,7 +1024,7 @@ sql_rel* rel_create_array(mvc *sql, sql_
}
//compute the repeats of the dimensional columns
- compute_repeats(sql, t);
+ //compute_repeats(sql, t);
temp = (tt == tt_array)?temp:SQL_PERSIST;
return rel_table(sql, DDL_CREATE_TABLE, sname, t, temp); //the
array does not differ from a table at least until this point
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
@@ -1065,13 +1065,13 @@ mvc_drop_column(mvc *m, sql_table *t, sq
}
sql_dimension *
-mvc_create_dimension(mvc *m, sql_table *t, const char *name, sql_subtype *tpe,
list* dimensionRange)
+mvc_create_dimension(mvc *m, sql_table *t, const char *name, sql_subtype *tpe)
{
if (mvc_debug)
fprintf(stderr, "#mvc_create_dimension %s %s %s\n",
t->base.name, name, tpe->type->sqlname);
if (isDeclaredArray(t) && (!t->s || strcmp(t->s->base.name,
dt_schema))) {
/* declared arrays should not end up in the catalog */
- return create_sql_dimension(m->sa, t, name, tpe,
dimensionRange);
+ return create_sql_dimension(m->sa, t, name, tpe);
}
else
fprintf(stderr, "sql/server/sql_mvc.c:1076 : I do not have an
implementation for this case\n");
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
@@ -185,7 +185,7 @@ extern sql_table *mvc_create_view(mvc *c
extern sql_table *mvc_create_remote(mvc *c, sql_schema *s, const char *name,
int persistence, const char *loc);
extern void mvc_drop_column(mvc *c, sql_table *t, sql_column *col, int
drop_action);
-extern sql_dimension *mvc_create_dimension(mvc *c, sql_table *t, const char
*name, sql_subtype *type, list* dimensionRange);
+extern sql_dimension *mvc_create_dimension(mvc *c, sql_table *t, const char
*name, sql_subtype *type);
extern sql_column *mvc_create_column(mvc *c, sql_table *t, const char *name,
sql_subtype *type);
extern sql_column *mvc_create_column_(mvc *c, sql_table *t, const char *name,
const char *type, int digits);
extern sql_column *mvc_null(mvc *c, sql_column *col, int flag);
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
@@ -122,6 +122,7 @@ typedef int (*prop_col_fptr) (sql_trans
-- create the necessary storage resources for columns, indices, arrays, and
tables
-- returns LOG_OK, LOG_ERR
*/
+//typedef int (*create_dim_fptr) (sql_trans *tr, sql_dimensin *dim);
typedef int (*create_col_fptr) (sql_trans *tr, sql_column *c);
typedef int (*create_idx_fptr) (sql_trans *tr, sql_idx *i);
typedef int (*create_del_fptr) (sql_trans *tr, sql_table *t);
@@ -196,6 +197,7 @@ typedef struct store_functions {
prop_col_fptr double_elim_col; /* varsize col with double elimination */
create_col_fptr create_col;
+// create_dim_fptr create_dim;
create_idx_fptr create_idx;
create_del_fptr create_del;
@@ -213,6 +215,7 @@ typedef struct store_functions {
/* functions for logging */
create_col_fptr log_create_col;
+// create_dim_fptr log_create_dim;
create_idx_fptr log_create_idx;
create_del_fptr log_create_del;
@@ -222,6 +225,7 @@ typedef struct store_functions {
/* functions for snapshots */
create_col_fptr snapshot_create_col;
+// create_dim_fptr snapshot_create_dim;
create_idx_fptr snapshot_create_idx;
create_del_fptr snapshot_create_del;
@@ -379,7 +383,7 @@ extern int sql_trans_disconnect_catalog_
extern sql_table *create_sql_table(sql_allocator *sa, const char *name, sht
type, bit system, int persistence, int commit_action);
extern sql_column *create_sql_column(sql_allocator *sa, sql_table *t, const
char *name, sql_subtype *tpe);
-extern sql_dimension *create_sql_dimension(sql_allocator *sa, sql_table *t,
const char *name, sql_subtype *tpe, list *range);
+extern sql_dimension *create_sql_dimension(sql_allocator *sa, sql_table *t,
const char *name, sql_subtype *tpe);
extern sql_ukey *create_sql_ukey(sql_allocator *sa, sql_table *t, const char
*nme, key_type kt);
extern sql_fkey *create_sql_fkey(sql_allocator *sa, sql_table *t, const char
*nme, key_type kt, sql_key *rkey, int on_delete, int on_update );
extern sql_key *create_sql_kc(sql_allocator *sa, sql_key *k, 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
@@ -524,6 +524,84 @@ load_column(sql_trans *tr, sql_table *t,
fprintf(stderr, "#\t\tload column %s\n", c->base.name);
return c;
}
+/*
+static sql_dimension *
+load_dimension(sql_trans *tr, sql_table *t, oid rid)
+{
+ void *v;
+ char *def, *tpe, *st, *min, *step, *max;
+ int sz, d;
+ sql_dimension *dim = SA_ZNEW(tr->sa, sql_dimension);
+ sql_schema *syss = find_sql_schema(tr, "sys");
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
