Changeset: 8f01c5b53893 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=8f01c5b53893
Modified Files:
gdk/gdk_arrays.c
gdk/gdk_arrays.h
monetdb5/modules/kernel/Makefile.ag
monetdb5/modules/kernel/algebra.mal
monetdb5/modules/kernel/arrays.c
monetdb5/modules/kernel/arrays.h
monetdb5/modules/kernel/arrays.mal
sql/backends/monet5/rel_bin.c
sql/backends/monet5/sql_arrays.c
sql/backends/monet5/sql_arrays.h
sql/backends/monet5/sql_arrays.mal
sql/backends/monet5/sql_gencode.c
sql/backends/monet5/sql_statement.c
sql/backends/monet5/sql_statement.h
Branch: arrays
Log Message:
the dimension are not BATs anymore but dimension structs.
the benefit is that now at any point I have access to the size
of all the dimensions
diffs (truncated from 1215 to 300 lines):
diff --git a/gdk/gdk_arrays.c b/gdk/gdk_arrays.c
--- a/gdk/gdk_arrays.c
+++ b/gdk/gdk_arrays.c
@@ -1,6 +1,39 @@
#include "monetdb_config.h"
#include "gdk_arrays.h"
+#define createDim(TPE) \
+gdk_dimension* createDimension_##TPE(int dimNum, BUN elsNum, TPE min, TPE max,
TPE step) { \
+ gdk_dimension *dim = GDKmalloc(sizeof(gdk_dimension)); \
+\
+ void *minVoid = GDKmalloc(sizeof(TPE)); \
+ void *maxVoid = GDKmalloc(sizeof(TPE)); \
+ void *stepVoid = GDKmalloc(sizeof(TPE)); \
+\
+ memcpy(minVoid, &min, sizeof(TPE)); \
+ memcpy(maxVoid, &max, sizeof(TPE)); \
+ memcpy(stepVoid, &step, sizeof(TPE)); \
+\
+ dim->type = TYPE_##TPE; \
+ dim->dimNum = dimNum; \
+ dim->elementsNum = floor((max - min )/ step)+1; \
+ dim->min = minVoid; \
+ dim->max = maxVoid; \
+ dim->step = stepVoid; \
+ dim->initialElementsNum = elsNum; \
+\
+ return dim; \
+}
+
+createDim(bte);
+createDim(sht);
+createDim(int);
+createDim(wrd);
+createDim(oid);
+createDim(lng);
+createDim(dbl);
+createDim(flt);
+
+
gdk_return gdk_error_msg(errors errorCode, const char* funcName, const char
*msg) {
switch(errorCode) {
case general_error:
@@ -17,6 +50,117 @@ gdk_return gdk_error_msg(errors errorCod
return GDK_FAIL;
}
+gdk_cells* cells_new(void) {
+ gdk_cells *cells = GDKmalloc(sizeof(gdk_cells));
+ cells->h = cells->t = NULL;
+ cells->dimsNum = 0;
+ return cells;
+}
+
+gdk_cells* cells_add_dimension(gdk_cells* cells, gdk_dimension *dim) {
+ dim_node *n = GDKmalloc(sizeof(dim_node));
+ n->next = NULL;
+ n->data = dim;
+
+
+ if (cells->dimsNum) {
+ cells->t->next = n;
+ } else {
+ cells->h = n;
+ }
+ cells->t = n;
+ cells->dimsNum++;
+
+ return cells;
+}
+
+static dim_node* findNode(gdk_cells *cells, int dimNum) {
+ dim_node *n;
+ for(n=cells->h; n->data->dimNum < dimNum; n=n->next);
+ return n;
+}
+
+static gdk_return freeDimension(gdk_dimension *dim) {
+ GDKfree(dim->min);
+ GDKfree(dim->max);
+ GDKfree(dim->step);
+ GDKfree(dim);
+
+ return GDK_SUCCEED;
+}
+
+gdk_cells* cells_remove_dimension(gdk_cells* cells, gdk_dimension *dim) {
+ dim_node *prevNode = findNode(cells, dim->dimNum-1);
+ dim_node *currNode = prevNode->next;
+
+ prevNode->next = currNode->next;
+
+ /* free the space allocated for the node that is being removed */
+ freeDimension(currNode->data);
+ GDKfree(currNode);
+
+ return cells;
+}
+
+gdk_cells* cells_replace_dimension(gdk_cells* cells, gdk_dimension *dim) {
+ dim_node *currNode = findNode(cells, dim->dimNum);
+
+ /* free the space that is allocated for the dimension that is being
replaced */
+ freeDimension(currNode->data);
+ /* set the data on the node to the new dimensions */
+ currNode->data = dim;
+
+ return cells;
+}
+
+
+/*
+#define valueInOID(oidVal, min, max, step) \
+do {\
+
+} while(0);
+
+BAT* projectDimension(gdk_dimension *oidsDim, gdk_dimension *valuesDim) {
+ switch(ATOMtype(valuesDim->type)) {
+ case TYPE_bte:
+ dim->elementsNum = floor((*(bte*)max - *(bte*)min )/
*(bte*)step)+1;
+ break;
+ case TYPE_sht:
+ dim->elementsNum = floor((*(sht*)max - *(sht*)min )/
*(sht*)step)+1;
+ break;
+ case TYPE_int:
+ dim->elementsNum = floor((*(int*)max - *(int*)min )/
*(int*)step)+1;
+ break;
+ case TYPE_flt:
+ dim->elementsNum = floor((*(flt*)max - *(flt*)min )/
*(flt*)step)+1;
+ break;
+ case TYPE_dbl:
+ dim->elementsNum = floor((*(dbl*)max - *(dbl*)min )/
*(dbl*)step)+1;
+ break;
+ case TYPE_lng:
+ dim->elementsNum = floor((*(lng*)max - *(lng*)min )/
*(lng*)step)+1;
+ break;
+#ifdef HAVE_HGE
+ case TYPE_hge:
+ dim->elementsNum = floor((*(hge*)max - *(hge*)min )/
*(hge*)step)+1;
+ break;
+#endif
+ case TYPE_oid:
+ dim->elementsNum = floor((*(oid*)max - *(oid*)min )/
*(oid*)step)+1;
+#if SIZEOF_OID == SIZEOF_INT
+#else
+ dim->elementsNum = floor((*(int*)max - *(int*)min )/
*(int*)step)+1;
+#endif
+ break;
+ default:
+ fprintf(stderr, "createDimension_NEW: dimension type not
handled\n");
+ return NULL;
+ }
+
+ return dim;
+}
+*/
+
#define createDimension(TPE, min, max, step, elementRepeats, groupRepeats) \
({ \
long i; \
diff --git a/gdk/gdk_arrays.h b/gdk/gdk_arrays.h
--- a/gdk/gdk_arrays.h
+++ b/gdk/gdk_arrays.h
@@ -4,6 +4,33 @@
#include "gdk.h"
#include <math.h>
+
+typedef struct dimStruct {
+ bte type;
+ int dimNum;
+ void *min;
+ void *max;
+ void *step;
+ BUN elementsNum;
+ BUN initialElementsNum;
+} gdk_dimension;
+
+typedef struct arrayStruct {
+ int dimsNum; //the number of dimensions
+ BUN *dimSizes; //an array having the size for each dimension
+} gdk_array;
+
+typedef struct dim_node {
+ struct dim_node *next;
+ gdk_dimension *data;
+} dim_node;
+
+typedef struct cells {
+ dim_node *h;
+ dim_node *t;
+ int dimsNum;
+} gdk_cells;
+
typedef enum errors {
general_error,
new_bat,
@@ -13,6 +40,112 @@ typedef enum errors {
gdk_return gdk_error_msg(errors errorCode, const char* funcName, const char
*msg);
+
+gdk_export gdk_dimension* createDimension_bte(int dimNum, BUN elsNum, bte min,
bte max, bte step);
+gdk_export gdk_dimension* createDimension_sht(int dimNum, BUN elsNum, sht min,
sht max, sht step);
+gdk_export gdk_dimension* createDimension_int(int dimNum, BUN elsNum, int min,
int max, int step);
+gdk_export gdk_dimension* createDimension_wrd(int dimNum, BUN elsNum, wrd min,
wrd max, wrd step);
+gdk_export gdk_dimension* createDimension_oid(int dimNum, BUN elsNum, oid min,
oid max, oid step);
+gdk_export gdk_dimension* createDimension_lng(int dimNum, BUN elsNum, lng min,
lng max, lng step);
+gdk_export gdk_dimension* createDimension_dbl(int dimNum, BUN elsNum, dbl min,
dbl max, dbl step);
+gdk_export gdk_dimension* createDimension_flt(int dimNum, BUN elsNum, flt min,
flt max, flt step);
+
+gdk_cells* cells_new(void);
+gdk_cells* cells_add_dimension(gdk_cells* cells, gdk_dimension *dim);
+gdk_cells* cells_remove_dimension(gdk_cells* cells, gdk_dimension *dim);
+gdk_cells* cells_replace_dimension(gdk_cells* cells, gdk_dimension* dim);
+
+#if 0
+#define dimensionElsNum(dim) \
+({ \
+ BUN els = 0; \
+ switch(dim->type.type->localtype) { \
+ case TYPE_bte: \
+ els = floor((dim->max->data.val.btval - dim->min->data.val.btval
)/ dim->step->data.val.btval)+1; \
+ break; \
+ case TYPE_sht: \
+ els = floor((dim->max->data.val.shval - dim->min->data.val.shval
)/ dim->step->data.val.shval)+1; \
+ break; \
+ case TYPE_int: \
+ els = floor((dim->max->data.val.ival - dim->min->data.val.ival )/
dim->step->data.val.ival)+1; \
+ break; \
+ case TYPE_wrd: \
+ els = floor((dim->max->data.val.wval - dim->min->data.val.wval )/
dim->step->data.val.wval)+1; \
+ break; \
+ case TYPE_oid: \
+ els = floor((dim->max->data.val.oval - dim->min->data.val.oval )/
dim->step->data.val.oval)+1; \
+ break; \
+ case TYPE_lng: \
+ els = floor((dim->max->data.val.lval - dim->min->data.val.lval )/
dim->step->data.val.lval)+1; \
+ break; \
+ case TYPE_dbl: \
+ els = floor((dim->max->data.val.dval - dim->min->data.val.dval )/
dim->step->data.val.dval)+1; \
+ break; \
+ case TYPE_flt: \
+ els = floor((dim->max->data.val.fval - dim->min->data.val.fval )/
dim->step->data.val.fval)+1; \
+ break; \
+ } \
+ els; \
+})
+#endif
+
+/*find the position in the dimension indices (no repetitions) of the given
value*/
+#define dimensionFndValuePos(value, min, step) fmod((value-min), step)?
BUN_NONE : (BUN)(value-min)/step
+/*find the position in the dimension indices (no repetitions) of the given
value
+ * or the position of the index that is closest to the given value and greater
than it*/
+#define dimensionFndGreaterValuePos(value, min, step, eq) \
+ ({\
+ BUN pos = (BUN)(value-min)/step; \
+ fmod((value-min), step) ? ++pos : (pos +(1-eq)); \
+ })
+
+/*find the position in the dimension indices (no repetitions) of the given
value
+ * or the position of the index that is closest to the given value and smaller
than it*/
+#define dimensionFndLowerValuePos(value, min, step, eq) \
+ ({\
+ BUN pos = (BUN)(value-min)/step; \
+ if(value < min) \
+ pos = -2; \
+ fmod((value-min), step) ? pos : (pos - (1-eq)); \
+ })
+
+
+
+#define equalIdx(dim, value) \
+({\
+ BUN idx = 0; \
+ switch(dim->type) { \
+ case TYPE_bte: \
+ idx = dimensionFndValuePos(*(bte*)value,
*(bte*)dim->min, *(bte*)dim->step); \
+ break; \
+ case TYPE_sht: \
+ idx = dimensionFndValuePos(*(sht*)value,
*(sht*)dim->min, *(sht*)dim->step); \
+ break; \
+ case TYPE_int:\
+ idx = dimensionFndValuePos(*(int*)value,
*(int*)dim->min, *(int*)dim->step); \
+ break; \
+ case TYPE_flt:\
+ idx = dimensionFndValuePos(*(flt*)value,
*(flt*)dim->min, *(flt*)dim->step); \
+ break; \
+ case TYPE_dbl:\
+ idx = dimensionFndValuePos(*(dbl*)value,
*(dbl*)dim->min, *(dbl*)dim->step); \
+ break; \
+ case TYPE_lng:\
+ idx = dimensionFndValuePos(*(lng*)value,
*(lng*)dim->min, *(lng*)dim->step); \
+ break; \
+ case TYPE_hge:\
+ idx = dimensionFndValuePos(*(hge*)value,
*(hge*)dim->min, *(hge*)dim->step); \
+ break; \
+ case TYPE_oid:\
+ idx = dimensionFndValuePos(*(oid*)value,
*(oid*)dim->min, *(oid*)dim->step); \
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
