Changeset: 13a4aa14fd87 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=13a4aa14fd87
Modified Files:
gdk/gdk_arrays.c
monetdb5/modules/mal/calc_arrays.c
monetdb5/modules/mal/calc_arrays.h
monetdb5/modules/mal/calc_arrays.mal
sql/backends/monet5/sql_gencode.c
Branch: arrays
Log Message:
calc.* and convert dimensions from one type to another
diffs (truncated from 2410 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
@@ -1881,5 +1881,3 @@ gdk_array *cellsToArray(gdk_cells *cells
return array;
}
#endif
-
-
diff --git a/monetdb5/modules/mal/calc_arrays.c
b/monetdb5/modules/mal/calc_arrays.c
--- a/monetdb5/modules/mal/calc_arrays.c
+++ b/monetdb5/modules/mal/calc_arrays.c
@@ -7,76 +7,2253 @@
#include "calc_arrays.h"
-str CMDdimensionCONVERT(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci) {
- char buf[20];
- ptr *dimConverted = getArgReference_ptr(stk, pci, 0);
- ptr *array_out = getArgReference_ptr(stk, pci, 1);
- ptr *dimOriginal = getArgReference_ptr(stk, pci, 2);
- ptr *array_in = getArgReference_ptr(stk, pci, 3);
+static BAT* dimension2BAT(const gdk_analytic_dimension *dim) {
+ BAT *dimBAT = BATnew(TYPE_void, dim->type, 3, TRANSIENT);
- gdk_analytic_dimension *dim_out = NULL;
- gdk_analytic_dimension *dim_in = (gdk_analytic_dimension*)*dimOriginal;
+ if(!dimBAT)
+ return NULL;
- //the array is not affected by the convertion
- //I just need to pass it along
- *array_out = *array_in;
+ BUNappend(dimBAT, dim->min, TRUE);
+ BUNappend(dimBAT, dim->max, TRUE);
+ BUNappend(dimBAT, dim->step, TRUE);
- (void) cntxt;
- (void) mb;
+ return dimBAT;
+}
+static gdk_analytic_dimension* BAT2dimension(BAT *dimBAT, int dimNum) {
+ BATiter biter = bat_iterator(dimBAT);
+ BUN currBun = BUNfirst(dimBAT);
+ switch(BATttype(dimBAT)) {
+ case TYPE_bte: {
+ bte min = *(bte*)BUNtail(biter, currBun);
+ bte max = *(bte*)BUNtail(biter, currBun+1);
+ bte step = *(bte*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_bte(dimNum, min, max,
step);
+ }
+ case TYPE_sht: {
+ short min = *(short*)BUNtail(biter, currBun);
+ short max = *(short*)BUNtail(biter, currBun+1);
+ short step = *(short*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_sht(dimNum, min, max,
step);
+ }
+ case TYPE_int: {
+ int min = *(int*)BUNtail(biter, currBun);
+ int max = *(int*)BUNtail(biter, currBun+1);
+ int step = *(int*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_int(dimNum, min, max,
step);
+ }
+ case TYPE_wrd: {
+ wrd min = *(wrd*)BUNtail(biter, currBun);
+ wrd max = *(wrd*)BUNtail(biter, currBun+1);
+ wrd step = *(wrd*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_wrd(dimNum, min, max,
step);
+ }
+ case TYPE_oid: {
+ oid min = *(oid*)BUNtail(biter, currBun);
+ oid max = *(oid*)BUNtail(biter, currBun+1);
+ oid step = *(oid*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_oid(dimNum, min, max,
step);
+ }
+ case TYPE_lng: {
+ long min = *(long*)BUNtail(biter, currBun);
+ long max = *(long*)BUNtail(biter, currBun+1);
+ long step = *(long*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_lng(dimNum, min, max,
step);
+ }
+ case TYPE_dbl: {
+ double min = *(double*)BUNtail(biter, currBun);
+ double max = *(double*)BUNtail(biter, currBun+1);
+ double step = *(double*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_dbl(dimNum, min, max,
step);
+ }
+ case TYPE_flt: {
+ float min = *(float*)BUNtail(biter, currBun);
+ float max = *(float*)BUNtail(biter, currBun+1);
+ float step = *(float*)BUNtail(biter, currBun+2);
+ return createAnalyticDimension_flt(dimNum, min, max,
step);
+ }
+ default:
+ return NULL;
+ }
+}
- (void)*buf;
- (void)*dim_in;
- (void)*dim_out;
- /*
- if (VARconvert(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)], 1) !=
GDK_SUCCEED) {
- snprintf(buf, sizeof(buf), "%s.%s", pci->modname, pci->fcnname);
- return mythrow(MAL, buf, OPERATION_FAILED);
- }*/
+static str CMDdimensionCONVERT(gdk_analytic_dimension **dimRes, const
gdk_analytic_dimension *dim, int type) {
+ int abort_on_error = 1;
+ BAT *dimBAT_in, *dimBAT_out, *s = NULL;
+ gdk_analytic_dimension *dim_out;
- *dimConverted = dim_out;
+ /* create a BAT and put inside the values of the dimensions */
+ /* needed to re-use functions that exist already */
+ if(!(dimBAT_in = dimension2BAT(dim)))
+ throw(MAL, "batcalc.convert", MAL_MALLOC_FAIL);
+
+ if(!(dimBAT_out = BATconvert(dimBAT_in, s, type, abort_on_error))) {
+ char buf[20];
+ snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(type));
+
+ BBPunfix(dimBAT_in->batCacheid);
+ return createException(MAL, buf, OPERATION_FAILED);
+ }
+
+ BBPunfix(dimBAT_in->batCacheid);
+
+ /*put the converted values from the BAT to the dim */
+ if(!(dim_out = BAT2dimension(dimBAT_out, dim->dimNum))) {
+ char buf[20];
+ snprintf(buf, sizeof(buf), "batcalc.%s", ATOMname(type));
+
+ BBPunfix(dimBAT_out->batCacheid);
+ return createException(MAL, buf, "Type not handled");
+ }
+
+ *dimRes = dim_out;
+
+ BBPunfix(dimBAT_out->batCacheid);
return MAL_SUCCEED;
}
+/*
+str CMDdimensionCONVERT_void(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_void);
+}
+
+str CMDdimensionCONVERT_bit(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_bit);
+}
+*/
+
+str CMDdimensionCONVERT_bte(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_bte);
+}
+
+str CMDdimensionCONVERT_sht(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_sht);
+}
+
+str CMDdimensionCONVERT_int(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_int);
+}
+
+str CMDdimensionCONVERT_wrd(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_wrd);
+}
+
+str CMDdimensionCONVERT_lng(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_lng);
+}
+
+str CMDdimensionCONVERT_flt(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_flt);
+}
+
+str CMDdimensionCONVERT_dbl(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_dbl);
+}
+
+str CMDdimensionCONVERT_oid(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_oid);
+}
+
+/*
+str CMDdimensionCONVERT_str(ptr *dimRes, ptr *dimsRes, const ptr *dim, const
ptr *dims) {
+ //the array is not affected by the convertion
+ //I just need to pass it along
+ gdk_array *array = arrayCopy((gdk_array*)*dims) ;
+ *dimsRes = array;
+
+ return CMDdimensionCONVERT((gdk_analytic_dimension**)dimRes,
(gdk_analytic_dimension*)*dim, TYPE_str);
+}*/
+
str CMDdimensionMULsignal(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr
pci) {
ptr *dimConverted = getArgReference_ptr(stk, pci, 0);
ptr *array_out = getArgReference_ptr(stk, pci, 1);
- void *val = getArgReference(stk, pci, 2);
+
+ void *valPtr = getArgReference(stk, pci, 2);
+ int valType = getArgType(mb, pci, 2);
+
ptr *dimOriginal = getArgReference_ptr(stk, pci, 3);
ptr *array_in = getArgReference_ptr(stk, pci, 4);
+
+ int *resType = getArgReference_int(stk, pci, 5);
gdk_analytic_dimension *dim_out = NULL;
gdk_analytic_dimension *dim_in = (gdk_analytic_dimension*)*dimOriginal;
+ int dimType = dim_in->type;
//the array is not affected by the convertion
//I just need to pass it along
- *array_out = *array_in;
+ gdk_array *array = arrayCopy((gdk_array*)*array_in);
+ *array_out = array;
(void) cntxt;
- (void) mb;
- (void)*(int*)val;
- (void)*dim_in;
- (void)*dim_out;
+ switch(valType) {
+ case TYPE_bte: {
+ bte val = *(bte*)valPtr;
+
+ switch(dimType) {
+ case TYPE_bte: {
+ bte min = *(bte*)dim_in->min;
+ bte max = *(bte*)dim_in->max;
+ bte step = *(bte*)dim_in->step;
-/*
- if (VARcalcmul(&stk->stk[getArg(pci, 0)], &stk->stk[getArg(pci, 1)],
&stk->stk[getArg(pci, 2)], 1) != GDK_SUCCEED)
- return mythrow(MAL, "calc.*", OPERATION_FAILED);
-*/
-
+ switch(*resType){
+ case TYPE_bte:
+ dim_out
=createAnalyticDimension_bte(dim_in->dimNum, min*val, max*val, step*val);
+ break;
+ case TYPE_sht:
+ dim_out
=createAnalyticDimension_sht(dim_in->dimNum, min*val, max*val, step*val);
+ break;
+ case TYPE_int:
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list
