Python search.SortOptions方法代码示例

# 需要导入模块: from google.appengine.api import search [as 别名]
# 或者: from google.appengine.api.search import SortOptions [as 别名]
def search_query(self, query_string, page=0):

        # Create sort options to sort on price and brand.
        sort_ts = search.SortExpression(
            expression='ts',
            direction=search.SortExpression.DESCENDING,
            default_value=0)
        sort_options = search.SortOptions(expressions=[sort_ts])

        # Create query options using the sort options and expressions created
        # above.
        query_options = search.QueryOptions(
            limit=self.MSG_PER_PAGE_NUM,
            offset=page * self.MSG_PER_PAGE_NUM,
            returned_fields=['msg_key'],
            sort_options=sort_options)

        # Build the Query and run the search
        try:
            query = search.Query(query_string=query_string, options=query_options)
        except search.QueryError:
            return []
        results = self.index.search(query)

        return results 

# 需要导入模块: from google.appengine.api import search [as 别名]
# 或者: from google.appengine.api.search import SortOptions [as 别名]
def search(
      cls, query_string='', query_limit=20, cursor=None, sort_options=None,
      returned_fields=None):
    """Searches for documents that match a given query string.

    Args:
      query_string: str, the query to match against documents in the index
      query_limit: int, the limit on number of documents to return in results.
      cursor: search.Cursor, a cursor describing where to get the next set of
          results, or to provide next cursors in SearchResults.
      sort_options: search.SortOptions, an object specifying a multi-dimensional
          sort over search results.
      returned_fields: List[str], an iterable of names of fields to return in
          search results.

    Returns:
      A SearchResults object containing a list of documents matched by the
          query.
    """
    index = cls.get_index()

    try:
      query = search.Query(
          query_string=cls.format_query(query_string),
          options=search.QueryOptions(
              cursor=cursor, limit=query_limit, sort_options=sort_options,
              returned_fields=returned_fields),
      )
    except search.QueryError:
      return search.SearchResults(number_found=0)

    return index.search(query) 

# 需要导入模块: from google.appengine.api import search [as 别名]
# 或者: from google.appengine.api.search import SortOptions [as 别名]
def set_search_query_options(request):
  """Sets the search query options based on a ProtoRPC request message.

  Args:
    request: messages.Message, The message that contains the values of the
        query options.

  Returns:
    A tuple containing the values of query options if they exist in the
        message.
  """
  try:
    query = request.query_string
  except AttributeError:
    query = None

  expressions = []
  sort_options = None
  try:
    for message_expression in request.expressions:
      direction = search.SortExpression.DESCENDING
      if (message_expression.direction ==
          shared_messages.SortDirection.ASCENDING):
        direction = search.SortExpression.ASCENDING
      expressions.append(
          search.SortExpression(
              expression=message_expression.expression, direction=direction))
    if expressions:
      sort_options = search.SortOptions(expressions=expressions)
  except AttributeError:
    # We do not want to do anything if the message does not have expressions
    # since sort_options is already set to None above.
    pass

  try:
    returned_fields = request.returned_fields
  except AttributeError:
    returned_fields = None

  return query, sort_options, returned_fields 

# 需要导入模块: from google.appengine.api import search [as 别名]
# 或者: from google.appengine.api.search import SortOptions [as 别名]
def find(query, count=10):
    sort_opts = search.SortOptions(expressions=[search.SortExpression(
        expression="date", direction=search.SortExpression.ASCENDING)])
    query_options = search.QueryOptions(limit=count, sort_options=sort_opts)
    query_obj = search.Query(query_string=query, options=query_options)
    results = index.search(query=query_obj)
    keys = []
    for result in results:
        keys.append(result.doc_id)
    return keys 

# 需要导入模块: from google.appengine.api import search [as 别名]
# 或者: from google.appengine.api.search import SortOptions [as 别名]
def query_options():
    index = search.Index('products')
    query_string = "product: piano AND price < 5000"

    # Create sort options to sort on price and brand.
    sort_price = search.SortExpression(
        expression='price',
        direction=search.SortExpression.DESCENDING,
        default_value=0)
    sort_brand = search.SortExpression(
        expression='brand',
        direction=search.SortExpression.DESCENDING,
        default_value="")
    sort_options = search.SortOptions(expressions=[sort_price, sort_brand])

    # Create field expressions to add new fields to the scored documents.
    price_per_note_expression = search.FieldExpression(
        name='price_per_note', expression='price/88')
    ivory_expression = search.FieldExpression(
        name='ivory', expression='snippet("ivory", summary, 120)')

    # Create query options using the sort options and expressions created
    # above.
    query_options = search.QueryOptions(
        limit=25,
        returned_fields=['model', 'price', 'description'],
        returned_expressions=[price_per_note_expression, ivory_expression],
        sort_options=sort_options)

    # Build the Query and run the search
    query = search.Query(query_string=query_string, options=query_options)
    results = index.search(query)
    for scored_document in results:
        print(scored_document)