Changeset: 58f3a64b1ced for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=58f3a64b1ced
Modified Files:
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_gencode.c
sql/backends/monet5/sql_statement.c
sql/backends/monet5/sql_statement.h
Branch: arrays
Log Message:
materialise oids before projecting the values
diffs (truncated from 441 to 300 lines):
diff --git a/monetdb5/modules/kernel/arrays.c b/monetdb5/modules/kernel/arrays.c
--- a/monetdb5/modules/kernel/arrays.c
+++ b/monetdb5/modules/kernel/arrays.c
@@ -169,7 +169,18 @@ static gdk_dimension* updateDimCandIdxs(
return dimCand;
}
-str ALGdimensionSubselect2(ptr *dimsRes, bat *oidsRes, const ptr *dim, const
ptr* dims, const ptr *dimsCands, const bat *oidsCands,
+str ALGmaterialise(bat* mbrResult, const ptr *dimsCands, const ptr *dims) {
+ gdk_array *dimCands_in = (gdk_array*)*dimsCands;
+ gdk_array *array = (gdk_array*)*dims;
+
+ BAT *mbrBAT = projectCells(dimCands_in, array);
+
+ BBPkeepref(*mbrResult = mbrBAT->batCacheid);
+
+ return MAL_SUCCEED;
+}
+
+str ALGdimensionSubselect2(ptr *dimsRes, const ptr *dim, const ptr* dims,
const ptr *dimsCands,
const void *low, const
void *high, const bit *li, const bit *hi, const bit *anti) {
gdk_array *array = (gdk_array*)*dims;
gdk_analytic_dimension *dimension = (gdk_analytic_dimension*)*dim;
@@ -180,12 +191,6 @@ str ALGdimensionSubselect2(ptr *dimsRes,
int type;
const void* nil;
- BAT *oidsResBAT = newempty("subselect"); //nothing returned in the oids
- BBPkeepref(*oidsRes = oidsResBAT->batCacheid);
-
- /*ingnore oidsCands. When projecting a dimension only the dimsCands are
of interest */
- (void)*oidsCands;
-
if(dimsCands)
dimCands_in = (gdk_array*)*dimsCands;
else //all dimensions are candidates
@@ -283,9 +288,9 @@ str ALGdimensionSubselect2(ptr *dimsRes,
return MAL_SUCCEED;
}
-str ALGdimensionSubselect1(ptr *dimsRes, bat *oidsRes, const ptr *dim, const
ptr* dims,
+str ALGdimensionSubselect1(ptr *dimsRes, const ptr *dim, const ptr* dims,
const void *low, const
void *high, const bit *li, const bit *hi, const bit *anti) {
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims, NULL, NULL,
low, high, li, hi, anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, NULL, low, high, li,
hi, anti);
}
str ALGdimensionSubselect3(ptr *dimsRes, bat *oidsRes, const ptr *array, const
bat *vals,
@@ -295,7 +300,7 @@ str ALGdimensionSubselect3(ptr *dimsRes,
}
-str ALGdimensionThetasubselect2(ptr *dimsRes, bat *oidsRes, const ptr *dim,
const ptr* dims, const ptr *dimsCands, const bat *oidsCands, const void *val,
const char **opp) {
+str ALGdimensionThetasubselect2(ptr *dimsRes, const ptr *dim, const ptr* dims,
const ptr *dimsCands, const void *val, const char **opp) {
bit li = 0;
bit hi = 0;
bit anti = 0;
@@ -307,53 +312,53 @@ str ALGdimensionThetasubselect2(ptr *dim
/* "=" or "==" */
li = hi = 1;
anti = 0;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims, dimsCands,
oidsCands, val, nil, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, val, nil,
&li, &hi, &anti);
}
if (op[0] == '!' && op[1] == '=' && op[2] == 0) {
/* "!=" (equivalent to "<>") */
li = hi = anti = 1;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims, dimsCands,
oidsCands, val, nil, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, val, nil,
&li, &hi, &anti);
}
if (op[0] == '<') {
if (op[1] == 0) {
/* "<" */
li = hi = anti = 0;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims,
dimsCands, oidsCands, nil, val, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, nil,
val, &li, &hi, &anti);
}
if (op[1] == '=' && op[2] == 0) {
/* "<=" */
li = anti = 0;
hi = 1;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims,
dimsCands, oidsCands, nil, val, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, nil,
val, &li, &hi, &anti);
}
if (op[1] == '>' && op[2] == 0) {
/* "<>" (equivalent to "!=") */
li = hi = anti = 1;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims,
dimsCands, oidsCands, val, nil, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, val,
nil, &li, &hi, &anti);
}
}
if (op[0] == '>') {
if (op[1] == 0) {
/* ">" */
li = hi = anti = 0;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims,
dimsCands, oidsCands, val, nil, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, val,
nil, &li, &hi, &anti);
}
if (op[1] == '=' && op[2] == 0) {
/* ">=" */
li = 1;
hi = anti = 0;
- return ALGdimensionSubselect2(dimsRes, oidsRes, dim, dims,
dimsCands, oidsCands, val, nil, &li, &hi, &anti);
+ return ALGdimensionSubselect2(dimsRes, dim, dims, dimsCands, val,
nil, &li, &hi, &anti);
}
}
throw(MAL, "algebra.dimensionThetasubselect", "BATdimensionThetasubselect:
unknown operator.\n");
}
-str ALGdimensionThetasubselect1(ptr *dimsRes, bat *oidsRes, const ptr *dim,
const ptr* dims, const void *val, const char **op) {
- return ALGdimensionThetasubselect2(dimsRes, oidsRes, dim, dims, NULL,
NULL, val, op);
+str ALGdimensionThetasubselect1(ptr *dimsRes, const ptr *dim, const ptr* dims,
const void *val, const char **op) {
+ return ALGdimensionThetasubselect2(dimsRes, dim, dims, NULL, val, op);
}
-str ALGdimensionLeftfetchjoin1(bat *result, const ptr *dimsCands, const bat
*oidsCands, const ptr *dim, const ptr *dims) {
+str ALGdimensionLeftfetchjoin1(bat *result, const ptr *dimsCands, const ptr
*dim, const ptr *dims) {
gdk_array *array = (gdk_array*)*dims;
gdk_analytic_dimension *dimension = (gdk_analytic_dimension*)*dim;
gdk_array *dimCands_in = (gdk_array*)*dimsCands;
@@ -361,9 +366,6 @@ str ALGdimensionLeftfetchjoin1(bat *resu
BAT *resBAT = NULL;
BUN resSize = 0;
- /*when projecting a dimension we ignore the oidsCands*/
- (void)*oidsCands;
-
if(!dimCands_in) { //empty
if(!(resBAT = newempty("dimensionLeftfetchjoin")))
throw(MAL, "algebra.leftfetchjoin", "Problem allocating
new BAT");
@@ -556,12 +558,15 @@ str ALGdimensionLeftfetchjoin2(bat *resu
}
-str ALGnonDimensionLeftfetchjoin1(bat* result, const ptr *dimsCands, const bat
*oidsCands, const bat *vals, const ptr *dims) {
+//str ALGnonDimensionLeftfetchjoin1(bat* result, const ptr *dimsCands, const
bat *oidsCands, const bat *vals, const ptr *dims) {
+str ALGnonDimensionLeftfetchjoin1(bat* result, const bat *mbrOids, const bat
*vals, const ptr *dims) {
+
/* projecting a non-dimensional column does not differ from projecting
any relational column */
- BAT *mbrCandsBAT = NULL, *oidsCandsBAT = NULL, *valsBAT = NULL,
*resBAT= NULL;
- gdk_array *dimCands_in = (gdk_array*)*dimsCands;
- gdk_array *array = (gdk_array*)*dims;
+ BAT *mbrCandsBAT = NULL/*, *oidsCandsBAT = NULL*/, *valsBAT = NULL,
*resBAT= NULL;
+// gdk_array *dimCands_in = (gdk_array*)*dimsCands;
+// gdk_array *array = (gdk_array*)*dims;
+#if 0
if(!dimCands_in) { //empty
if(!(resBAT = newempty("nonDimensionLeftfetchjoin1")))
throw(MAL, "algebra.leftfetchjoin", "Problem allocating new BAT");
@@ -569,19 +574,28 @@ str ALGnonDimensionLeftfetchjoin1(bat* r
return MAL_SUCCEED;
}
+#endif
+ (void)*dims;
- if ((oidsCandsBAT = BATdescriptor(*oidsCands)) == NULL) {
+// if ((oidsCandsBAT = BATdescriptor(*oidsCands)) == NULL) {
+// throw(MAL, "algebra.leftfetchjoin", RUNTIME_OBJECT_MISSING);
+// }
+
+ if ((valsBAT = BATdescriptor(*vals)) == NULL) {
+// BBPunfix(oidsCandsBAT->batCacheid);
throw(MAL, "algebra.leftfetchjoin", RUNTIME_OBJECT_MISSING);
}
- if ((valsBAT = BATdescriptor(*vals)) == NULL) {
- BBPunfix(oidsCandsBAT->batCacheid);
+ if ((mbrCandsBAT = BATdescriptor(*mbrOids)) == NULL) {
+// BBPunfix(oidsCandsBAT->batCacheid);
+ BBPunfix(valsBAT->batCacheid);
throw(MAL, "algebra.leftfetchjoin", RUNTIME_OBJECT_MISSING);
}
//create the oids using the candidates
- mbrCandsBAT = projectCells(dimCands_in, array);
+// mbrCandsBAT = projectCells(dimCands_in, array);
+#if 0
if(BATcount(oidsCandsBAT)) { /*there is mbr and oids. Some values need
to be set to null */
BAT *r1p, *r2p, *r3p;
@@ -598,6 +612,7 @@ str ALGnonDimensionLeftfetchjoin1(bat* r
BBPunfix(r2p->batCacheid);
BBPunfix(r3p->batCacheid);
} else
+#endif
resBAT = BATproject(mbrCandsBAT, valsBAT);
#if 0
@@ -631,7 +646,7 @@ str ALGnonDimensionLeftfetchjoin1(bat* r
BBPunfix(mbrCandsBAT->batCacheid);
BBPunfix(valsBAT->batCacheid);
- BBPunfix(oidsCandsBAT->batCacheid);
+// BBPunfix(oidsCandsBAT->batCacheid);
if (resBAT == NULL)
throw(MAL, "algebra.leftfetchjoin", GDK_EXCEPTION);
@@ -986,8 +1001,7 @@ str ALGarrayCount(wrd *res, const ptr *a
str ALGprojectDimension(bat* result, const ptr *dim, const ptr *array) {
const gdk_array *dimsCands = arrayCopy((gdk_array*)*array);
//candidates exactly the same to the array
- bat oidsCands;
- return ALGdimensionLeftfetchjoin1(result, (void*)&dimsCands,
&oidsCands, dim, array);
+ return ALGdimensionLeftfetchjoin1(result, (void*)&dimsCands, dim,
array);
}
str ALGprojectNonDimension(bat *result, const bat *vals, const ptr *array) {
diff --git a/monetdb5/modules/kernel/arrays.h b/monetdb5/modules/kernel/arrays.h
--- a/monetdb5/modules/kernel/arrays.h
+++ b/monetdb5/modules/kernel/arrays.h
@@ -12,21 +12,24 @@
#define algebra_export extern
#endif
-algebra_export str ALGdimensionLeftfetchjoin1(bat* result, const ptr
*dimsCands, const bat* oidsCands, const ptr *dim, const ptr *dims) ;
+algebra_export str ALGmaterialise(bat* mbrResult, const ptr *dimsCands, const
ptr *dims) ;
+
+algebra_export str ALGdimensionLeftfetchjoin1(bat* result, const ptr
*dimsCands, const ptr *dim, const ptr *dims) ;
algebra_export str ALGdimensionLeftfetchjoin2(bat* result, const ptr*
dimsCands, const bat* oidsCands, const ptr *array);
-algebra_export str ALGnonDimensionLeftfetchjoin1(bat* result, const ptr
*dimsCands, const bat* oidsCands, const bat *vals, const ptr *dims);
+//algebra_export str ALGnonDimensionLeftfetchjoin1(bat* result, const ptr
*dimsCands, const bat* oidsCands, const bat *vals, const ptr *dims);
+algebra_export str ALGnonDimensionLeftfetchjoin1(bat* result, const bat*
mbrOids, const bat *vals, const ptr *dims);
algebra_export str ALGnonDimensionLeftfetchjoin2(bat* result, ptr* dimsRes,
const ptr *array, const bat *vals, const ptr *dims);
-algebra_export str ALGdimensionSubselect2(ptr *dimsRes, bat *oidsRes, const
ptr *dim, const ptr* dims, const ptr *dimsCands, const bat* oidsCands,
+algebra_export str ALGdimensionSubselect2(ptr *dimsRes, const ptr *dim, const
ptr* dims, const ptr *dimsCands,
const void *low, const void *high, const bit *li,
const bit *hi, const bit *anti);
-algebra_export str ALGdimensionSubselect1(ptr *dimsRes, bat *oidsRes, const
ptr *dim, const ptr* dims,
+algebra_export str ALGdimensionSubselect1(ptr *dimsRes, const ptr *dim, const
ptr* dims,
const void *low, const void *high, const bit *li,
const bit *hi, const bit *anti);
algebra_export str ALGdimensionSubselect3(ptr *dimsRes, bat *oidsResi, const
ptr *array, const bat *vals,
const void *low, const
void *high, const bit *li, const bit *hi, const bit *anti);
-algebra_export str ALGdimensionThetasubselect2(ptr *dimsRes, bat *oidsRes,
const ptr *dim, const ptr* dims, const ptr *dimsCand, const bat *oidsCands,
+algebra_export str ALGdimensionThetasubselect2(ptr *dimsRes, const ptr *dim,
const ptr* dims, const ptr *dimsCand,
const void *val, const char **op);
-algebra_export str ALGdimensionThetasubselect1(ptr *dimsRes, bat *oidsRes,
const ptr *dim, const ptr* dims,
+algebra_export str ALGdimensionThetasubselect1(ptr *dimsRes, const ptr *dim,
const ptr* dims,
const void *val, const char **op);
algebra_export str ALGnonDimensionSubselect1(ptr *dimsRes, bat *oidsRes, const
bat *values, const ptr *dims,
diff --git a/monetdb5/modules/kernel/arrays.mal
b/monetdb5/modules/kernel/arrays.mal
--- a/monetdb5/modules/kernel/arrays.mal
+++ b/monetdb5/modules/kernel/arrays.mal
@@ -1,13 +1,21 @@
+#it creates the oids out of the qualifying indices of the dimensions (the mbr)
+command algebra.materialise(dimsCands:ptr, dims:ptr) :bat[:oid,:oid]
+address ALGmaterialise;
+
+
#It gets the candidates and projects the dimensions
#With project cells: command algebra.leftfetchjoin(cands:bat[:oid,:oid],
dim:ptr, dims:ptr ) :bat[:oid,:any]
-command algebra.leftfetchjoin(dimsCands:ptr, oidsCands:bat[:oid,:oid],
dim:ptr, dims:ptr ) :bat[:oid,:any]
+#command algebra.leftfetchjoin(dimsCands:ptr, oidsCands:bat[:oid,:oid],
dim:ptr, dims:ptr ) :bat[:oid,:any]
+#address ALGdimensionLeftfetchjoin1;
+command algebra.leftfetchjoin(dimsCands:ptr, dim:ptr, dims:ptr )
:bat[:oid,:any]
address ALGdimensionLeftfetchjoin1;
#it is called in updates. It projects all cells
command algebra.leftfetchjoin(dimsCands:ptr, oidsCands:bat[:oid,:oid],
array:ptr) :bat[:oid,:oid]
address ALGdimensionLeftfetchjoin2;
#it gets the candidates and projects a non-dimensional column
#with project cells: command algebra.leftfetchjoin(cands:bat[:oid,:oid],
vals:bat[:oid,:any], dims:ptr ) :bat[:oid,:any]
-command algebra.leftfetchjoin(candDims:ptr, candBAT:bat[:oid,:oid],
vals:bat[:oid,:any], dims:ptr ) :bat[:oid,:any]
+#command algebra.leftfetchjoin(candDims:ptr, candBAT:bat[:oid,:oid],
vals:bat[:oid,:any], dims:ptr ) :bat[:oid,:any]
+command algebra.leftfetchjoin(mbrBAT:bat[:oid,:oid], vals:bat[:oid,:any],
dims:ptr ) :bat[:oid,:any]
address ALGnonDimensionLeftfetchjoin1;
#it is called when projecting a non-dimensional column of an array
command algebra.leftfetchjoin(array:ptr,vals:bat[:oid,:any],dims:ptr)
(:bat[:oid,:any], :ptr)
@@ -17,15 +25,27 @@ address ALGnonDimensionLeftfetchjoin2;
#the first result is the mbr and the second is the oids that satisfy the
conditiont
#it is always null but it is used to avoid having to check whether the
selection
#is on a dimension or a non-dimension when creating the MAL plan
-command algebra.subselect(dim:ptr, dims:ptr, low:any, high:any, li:bit,
hi:bit, anti:bit) (:ptr, :bat[:oid,:oid])
+#command algebra.subselect(dim:ptr, dims:ptr, low:any, high:any, li:bit,
hi:bit, anti:bit) (:ptr, :bat[:oid,:oid])
+#address ALGdimensionSubselect1;
+#command algebra.thetasubselect(dim:ptr, dims:ptr, val:any, op:str) (:ptr,
:bat[:oid,:oid])
+#address ALGdimensionThetasubselect1;
+#
+#A selection over a dimension always results in a new array with updated
dimension
+command algebra.subselect(dim:ptr, dims:ptr, low:any, high:any, li:bit,
hi:bit, anti:bit) :ptr
address ALGdimensionSubselect1;
-command algebra.thetasubselect(dim:ptr, dims:ptr, val:any, op:str) (:ptr,
:bat[:oid,:oid])
+command algebra.thetasubselect(dim:ptr, dims:ptr, val:any, op:str) :ptr
address ALGdimensionThetasubselect1;
#the candBAT will be null when the candidates come from selection over
dimensional column
#and non-zero when coming from selection over non-dimensional column
-command algebra.subselect(dim:ptr, dims:ptr, candDims:ptr,
candBAT:bat[:oid,:oid], low:any, high:any, li:bit, hi:bit, anti:bit) (:ptr,
:bat[:oid,:oid])
+#command algebra.subselect(dim:ptr, dims:ptr, candDims:ptr,
candBAT:bat[:oid,:oid], low:any, high:any, li:bit, hi:bit, anti:bit) (:ptr,
:bat[:oid,:oid])
+#address ALGdimensionSubselect2;
+#command algebra.thetasubselect(dim:ptr, dims:ptr, candDims:ptr,
candBAT:bat[:oid,:oid], val:any, op:str) (:ptr, :bat[:oid,:oid])
+#address ALGdimensionThetasubselect2;
+#
+#The candidates is an array with some other dimension already updated
+command algebra.subselect(dim:ptr, dims:ptr, candDims:ptr, low:any, high:any,
li:bit, hi:bit, anti:bit) :ptr
address ALGdimensionSubselect2;
-command algebra.thetasubselect(dim:ptr, dims:ptr, candDims:ptr,
candBAT:bat[:oid,:oid], val:any, op:str) (:ptr, :bat[:oid,:oid])
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list
