int match(const ConditionSet *cs, const void *tuple, const TupleLayout *tl) {
        for(int c=0; c<cs->count(); c++) {
                istrue( (*cs)[c],
                        (*tl)[(*cs)[c].tupleindex].type,
                        tl->queryPointer((*cs)[c].tupleindex,tuple));
        }
}



#define TEST(type,op,p1,p2) if(!(*(type*)p1) op (*(type*)p2)) return 0;
#define TESTARIT(type,p1,p2) \
case COND_LT: TEST(type,<,p1,p2)
case COND_LE: TEST(type,<=,p1,p2)
case COND_EQ: TEST(type,==,p1,p2)
case COND_GE: TEST(type,>=,p1,p2)
case COND_GT: TEST(type,>,p1,p2)
case COND_NE: TEST(type,!=,p1,p2)

int istrue(const Condition& c, int attrtype, const void *tupleattr) {
        switch(attrtype) {
                case ATTRTYPE_UINT8: {
                        switch(c.cond) {
                        TESTARIT(uint8,tupleattr,c.value)
                        }
                case ATTRTYPE_SINT8: {
                        switch(c.cond) {
                        TESTARIT(sint8,tupleattr,c.value)
                        }
                case ATTRTYPE_UINT16: {
                        switch(c.cond) {
                        TESTARIT(uint16,tupleattr,c.value)
                        }
                case ATTRTYPE_SINT16: {
                        switch(c.cond) {
                        TESTARIT(sint16,tupleattr,c.value)
                        }
                case ATTRTYPE_UINT32: {
                        switch(c.cond) {
                        TESTARIT(uint32,tupleattr,c.value)
                        }
                case ATTRTYPE_SINT32: {
                        switch(c.cond) {
                        TESTARIT(sint32,tupleattr,c.value)
                        }
                case ATTRTYPE_UINT64: {
                        switch(c.cond) {
                        TESTARIT(uint64,tupleattr,c.value)
                        }
                case ATTRTYPE_FLOAT32: {
                        switch(c.cond) {
                        TESTARIT(float32,tupleattr,c.value)
                        }
                case ATTRTYPE_FLOAT64: {
                        switch(c.cond) {
                        TESTARIT(float64,tupleattr,c.value)
                        }
                case ATTRTYPE_DECIMAL: {
                        switch(c.cond) {
                        TESTARIT(decimal,tupleattr,c.value)
                        }
                case ATTRTYPE_CHAR:
                case ATTRTYPE_VARCHAR: {
                        switch(c.cond) {
                                case COND_LT:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) < 0;
                                case COND_LE:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) <= 0;
                                case COND_EQ:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) == 0;
                                case COND_GE:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) >= 0;
                                case COND_GT:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) > 0;
                                case COND_NE:
                                        return strcmp((const char*)tupleattr,(const char*)c.value) != 0;
                                case COND_BEGINS:
                                        return(strncmp((const char*)c.value, (const char*)tupleattr, strlen((const char*)c.value)) == 0;
                        }
                case ATTRTYPE_BOOL:
                        switch(c.cond) {
                                case COND_EQ:
                                        return *(bool*)tupleattr == *(bool*)c.value;
                                case COND_NE:
                                        return *(bool*)tupleattr != *(bool*)c.value;
                        }
        }
}