def where_terms(self, term_list, cache=False):
        """
        Create a boolean array where `term_list` is true.
        A terms list has a [(col, operator, value), ..] construction.
        Eg. [('sales', '>', 2), ('state', 'in', ['IL', 'AR'])]

        :param term_list:
        :param outcols:
        :param limit:
        :param skip:
        :return: :raise ValueError:
        """

        if type(term_list) not in [list, set, tuple]:
            raise ValueError("Only term lists are supported")

        col_list = []
        op_list = []
        value_list = []

        for term in term_list:
            # get terms
            filter_col = term[0]
            filter_operator = term[1].lower().strip(' ')
            filter_value = term[2]

            # check values
            if filter_col not in self.cols:
                raise KeyError(unicode(filter_col) + ' not in table')

            if filter_operator in ['==', 'eq']:
                op_id = 1
            elif filter_operator in ['!=', 'neq']:
                op_id = 2
            elif filter_operator in ['in']:
                op_id = 3
            elif filter_operator in ['nin', 'not in']:
                op_id = 4
            elif filter_operator in ['>']:
                op_id = 5
            elif filter_operator in ['>=']:
                op_id = 6
            elif filter_operator in ['<']:
                op_id = 7
            elif filter_operator in ['<=']:
                op_id = 8
            else:
                raise KeyError(unicode(filter_operator) + ' is not an accepted operator for filtering')

            if op_id in [3, 4]:
                if type(filter_value) not in [list, set, tuple]:
                    raise ValueError("In selections need lists, sets or tuples")

                if len(filter_value) < 1:
                    raise ValueError("A value list needs to have values")

                # optimize lists of 1 value
                if len(filter_value) == 1:
                    if op_id == 3:
                        op_id = 1
                    else:
                        op_id = 2

                    filter_value = filter_value[0]
                else:
                    filter_value = set(filter_value)

            # prepare input for filter creation
            col_list.append(filter_col)
            op_list.append(op_id)
            value_list.append(filter_value)

        # rootdir
        if cache:
            # nb: this directory is not destroyed until the end of the groupby
            rootdir = self.create_tmp_rootdir()
        else:
            rootdir = None

        # create boolean array and fill it
        boolarr = bcolz.carray(np.ones(0, dtype=np.bool), expectedlen=self.len, rootdir=rootdir, mode='w')
        ctable_iter = self[col_list].iter(out_flavor='tuple')
        ctable_ext.apply_where_terms(ctable_iter, op_list, value_list, boolarr)

        return boolarr
Create a boolean array where `term_list` is true.
        A terms list has a [(col, operator, value), ..] construction.
        Eg. [('sales', '>', 2), ('state', 'in', ['IL', 'AR'])]

        :param term_list:
        :param outcols:
        :param limit:
        :param skip:
        :return: :raise ValueError: