docs: def whooshee_search(self, search_string, group=whoosh.qparser.OrGroup, whoosheer=None,
                          match_substrings=True, limit=None, order_by_relevance=10):
          """Do a fulltext search on the query.
          Returns a query filtered with results of the fulltext search.
  
          :param search_string: The string to search for.
          :param group: The whoosh group to use for searching.
                        Defaults to :class:`whoosh.qparser.OrGroup` which
                        searches for all words in all columns.
          :param match_substrings: ``True`` if you want to match substrings,
                                   ``False`` otherwise
          :param limit: The number of the top records to be returned.
                        Defaults to ``None`` and returns all records.
          """
          if not whoosheer:
              ### inspiration taken from flask-WhooshAlchemy
              # find out all entities in join
              entities = set()
              # directly queried entities
              for cd in self.column_descriptions:
                  entities.add(cd['type'])
              # joined entities
              if self._join_entities and isinstance(self._join_entities[0], Mapper):
                  # SQLAlchemy >= 0.8.0
                  entities.update(set([x.entity for x in self._join_entities]))
              else:
                  # SQLAlchemy < 0.8.0
                  entities.update(set(self._join_entities))
              # make sure we can work with aliased entities
              unaliased = set()
              for entity in entities:
                  if isinstance(entity, (AliasedClass, AliasedInsp)):
                      unaliased.add(inspect(entity).mapper.class_)
                  else:
                      unaliased.add(entity)
  
              whoosheer = next(w for w in _get_config(self)['whoosheers']
                               if set(w.models) == unaliased)
  
          # TODO what if unique field doesn't exist or there are multiple?
          for fname, field in list(whoosheer.schema._fields.items()):
              if field.unique:
                  uniq = fname
  
          # TODO: use something more general than id
          res = whoosheer.search(search_string=search_string,
                                 values_of=uniq,
                                 group=group,
                                 match_substrings=match_substrings,
                                 limit=limit)
          if not res:
              return self.filter(text('null'))
  
          # transform unique field name into model attribute field
          attr = None
  
          if hasattr(whoosheer, '_is_model_whoosheer'):
              attr = getattr(whoosheer.models[0], uniq)
          else:
              # non-model whoosheers must have unique field named
              # model.__name__.lower + '_' + attr
              for m in whoosheer.models:
                  if m.__name__.lower() == uniq.split('_')[0]:
                      attr = getattr(m, uniq.split('_')[1])
  
          search_query = self.filter(attr.in_(res))
  
          if order_by_relevance < 0: # we want all returned rows ordered
              search_query = search_query.order_by(sqlalchemy.sql.expression.case(
                  [(attr == uniq_val, index) for index, uniq_val in enumerate(res)],
              ))
          elif order_by_relevance > 0: # we want only number of specified rows ordered
              search_query = search_query.order_by(sqlalchemy.sql.expression.case(
                  [(attr == uniq_val, index) for index, uniq_val in enumerate(res) if index < order_by_relevance],
                  else_=order_by_relevance
              ))
          else: # no ordering
              pass
  
          return search_query