def select(self, txn, from_key=None, to_key=None, return_keys=True, return_values=True, reverse=False, limit=None):
        """
        Select all records (key-value pairs) in table, optionally within a given key range.

        :param txn: The transaction in which to run.
        :type txn: :class:`zlmdb.Transaction`

        :param from_key: Return records starting from (and including) this key.
        :type from_key: object

        :param to_key: Return records up to (but not including) this key.
        :type to_key: object

        :param return_keys: If ``True`` (default), return keys of records.
        :type return_keys: bool

        :param return_values: If ``True`` (default), return values of records.
        :type return_values: bool

        :param limit: Limit number of records returned.
        :type limit: int

        :return:
        """
        assert type(return_keys) == bool
        assert type(return_values) == bool
        assert type(reverse) == bool
        assert limit is None or (type(limit) == int and limit > 0 and limit < 10000000)

        return PersistentMapIterator(txn,
                                     self,
                                     from_key=from_key,
                                     to_key=to_key,
                                     return_keys=return_keys,
                                     return_values=return_values,
                                     reverse=reverse,
                                     limit=limit)