code: def select(self, txn, from_key=None, to_key=None, return_keys=True, return_values=True, reverse=False, limit=None):
          
          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)
docs: 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: