Search query

Available in Classic and VPC

Cloud Search provides a Search API for searching. You can search using the document settings and index settings set when creating the domain. You can select search requests in one of the following ways:

• Enter in the request body: enter the search query in the request body when requesting an API
• Enter in URI: enter the search query into the URL when requesting an API

Search query guides you through the format of search queries and descriptions and examples for each field.

Enter in the request body

Call the API by putting your search query in the request body.

• Enter in Query DSL format with JSON.
• Select HTTP POST as the method.

The template for the search query entered in the request body is as follows:

{
  "start": (string|int),

  "display": (string|int),

  "result_format": (string),

  "search": {
    "[index_name]": {
      "[query_method]": [{
        "query": (string),
        "name": (string),
        "type": (string),
        "option": (string|bool),
        "ratio": (string|double),
        "term_extractor": (string),
        "syno": (bool),
        "stopword": (string)
      }]
    }
  },

  "sort": {
    "[sort_target]": (string)
  },

  "scope": {
    "[scope_target]": {
      "[scope_method]": (string|int|double|array)
    }
  },

  "key_scope": {
    "[scope_method]": (string|array)
  },

  "user_scope": (string),

  "highlighting": {
    "enable": (string|bool),
    "pre_tag": (string),
    "post_tag": (string),
    "[highlighting_option]": (string|bool)
  },

  "display_section": (string|array),
  "passage": {
    "[section_name]": {
       "passage_type": (string),
       "passage_option": (string),
       "max_length": (string)
    },
  },

  "aggregate": {
    "[docprop_name]": {
      "max": (string),
      "min": (string),
      "one": (string),
      "sum": (string)
    }
  },

  "result_processing": {
    "[section_name]": {
      "remove_duplicate": (string|bool)
    }
  },

  "setting": {
    "transfer_timeout": (string|int),
    "search_timeout": (string|int),
    "use_df": (string|bool),
    "reuse_term_extractor": (string|bool),
    "log_level": (string|list),
  }
}

The following describes each field.

start

This field selects the starting ranking of search results to be displayed. The default is 1, and the input format is:

{
  "start": (string|int)
}

<Example>

{
  "start": 1,
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
}

display

This field selects the number of search results to be displayed. The default is 20, and the input format is:

{
  "display": (string|int)
}

<Example>

{
  "display": 20,
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
}

result_format

Select the format of search results. The input format is as follows.

{
  "result_format": (string)
}

• result_format: select the format of search results between json or xml (default: json)

  <Example>

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
        }
      }
    },
    "result_format": "json"
  }
  

search

This is a required field for searching. The input format is as follows.

{
  "search": {
    "[index_name]": {
      "[query_method]": {
        "query": (string),
        "name": (string),
        "type": (string),
        "option": (string),
        "ratio": (string|double),
        "term_extractor": (string),
        "syno": (bool),
        "stopword": (string)
      }
    }
  }
}

• [index_name]: specifies the index to search
• [query_method]: selects search method
  • main: must be included in search requests and specifies the main query.
    • The search result is the result of the union operation from the result set of the main query.
  • intersection: specifies an intersection query.
    • The search result is the result of the intersection operation from the result set of the main query and the intersection query.
  • scope: specifies a scope query. It has the same effect as an intersection query, but does not change the document weights (qds).
  • exclusion: specifies an exclusion query.
    • The search result is the result of the difference between the result set of the main, intersection, and scope queries and the result set of the exclusion query.
  • rerank: does not affect search results, but changes document weight (qds).
    • Available query types: simbst, proxrank
• query: specifies search query
• name: specifies the query name to use when searching
• type: specifies query type
  • oneterm: it is used if there is only one term in the query, and it finds documents including the term. When there are multiple terms, it uses the first analyzed term.
  • nterm: it is used if there are multiple terms in the query, and it finds documents including the word. You can use option parameters.
  • nofm: finds documents where the term of the query is greater than or equal to the percentage specified by the ratio parameter.
  • ebool: finds documents that satisfy results to combine boolean operators.
    • Available operators: &(AND), |(OR), !(NOT)
    • You can enter multiple operators.
    • Users who are searching can directly enter operators, and operators (&, |, !) must be left and right with spaces to be recognized as operators.
    • You must create a bool expression by constructing the relationship between index words and operators in postorder form.
  • simbst: among the searched documents, increases the document weight (qds) of the documents containing the query word by the value given as a ratio parameter.
  • proxrank: calculates prox.
  • null: searches all documents with empty query.
• option: specifies options of query type
  • and: searches only for documents that contain all given terms.
  • or: searches for all documents that contain at least one of the given terms.
  • advance: searches for documents that contain all given terms in the same order and consists of the distance between two adjacent index words does not exceed the difference in position.
  • near: searches for documents that contain all given terms in any order and have two close index words that stay within the given distance.
  • within: searches for documents that contain all given terms in the exact same order and have two close index words that stay within the given distance.
  • ormax: same as or, but selects the index word with the largest ranking value among the index words to which the operator is applied. Used in synonym search.
• ratio: specifies ratio when using a specific query type (nofm, simbst)
• term_extractor: specifies the method to extract the term of the search query (default: index's analysis option)
  • Make sure to select this option if you would like to use both Korean and English in the schema analyzer.
  • <Example> "term_extractor": "sgmt +english +revert +korea +josacat +eomicat"
  • When used, you must add "reuse_term_extractor": true options to the setting field.
• syno: selects whether to use thesaurus
• stopword: enters the stopword rule to apply

An example of writing the search field is as follows.

• Examples by search method ([query_method])
  <Example> main query

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "nterm",
          "option": "and"
        }
      }
    }
  }
  

  <Example> intersection query

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "nterm",
          "option": "and"
        },
        "intersection": {
          "query": "good",
          "type": "nterm",
          "option": "and"
        }
      }
    }
  }
  

  <Example> scope query

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "nterm",
          "option": "and"
        },
        "scope": {
          "query": "good",
          "type": "nterm",
          "option": "and"
        }
      }
    }
  }
  

  <Example> exclusion query

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "nterm",
          "option": "and"
        },
        "exclusion": {
          "query": "bad",
          "type": "nterm",
          "option": "and"
        }
      }
    }
  }
  

  <Example> rerank query

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "nterm",
          "option": "and"
        },
        "rerank": {
          "query": "good",
          "type": "simbst",
          "ratio": 0.7
        }
      }
    }
  }
  

• Examples by query type(type)
  <Example> oneterm type

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search",
          "type": "oneterm"
        }
      }
    }
  }
  

  <Example> nterm type

  {
    "search": {
      "title_sgmt": {
        "main": {
          "query": "search is good",
        }
      }
    }
  }
  

  <Example> nform type

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search is good",
          "type": "nofm",
          "ratio": 0.7
        }
      }
    }
  }
  

  <Example> ebool type

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "search | good & bad ! doesn’t work" ,
          "type": "ebool"
        }
      }
    }
  }
  

  <Example> simbst type

  {
    "search": {
      "body_sgmt": {
        "main": {
          "query": "test"
        },
        "rerank": {
          "query": "search",
          "type": "simbst",
          "ratio": 0.7
        }
      }
    }
  }
  

  <Example> proxrank type

  {
    "search": {
      "title_sgmt": {
        "main": {
          "query": "test"
        },
        "rerank": {
          "query": "search",
          "type": "proxrank",
          "option": "exprox"
        }
      }
    }
  }
  

  <Example> null type

  {
    "search": {
      "body_sgmt": {
        "main": {
          "type": "null"
        }
      }
    }
  }
  

• Example of searching multiple indexes
  <Example> main query

  {
    "search": {
      "Index_A": {
        "main": [{
          "query": "a"
        },{
          "query": "b"
        }]
      },
      "Index_B": {
        "main": {
          "query": "c"
        }
      }
    }
  }
  

  <Example> main query + intersection query

  {
     "search": {
       "Index_A": {
         "main": {
           "query": "a"
         }
       },
       "Index_B": {
         "main": {
           "query": "b"
         }
       },
       "Index_C": {
         "intersection": {
           "query" : "c"
         }
       }
     }
  }
  

  <Example> main query + exclusion query

  {
      "search": {
       "Index_A": {
         "main": {
           "query": "a"
         }
       },
       "Index_B": {
         "main": {
           "query": "b"
         }
       },
       "Index_C": {
         "exclusion": {
           "query" : "c"
         }
       }
     }
  }
  

sort

This is a field for setting criteria of search results. The input format is as follows.

{
  "sort": {
    "[sort_target]": [sort_option](string)
  }
}

• [sort_target]: specifies sorting criteria
  • Enter a document attribute or a variable in the ranking module
• [sort_option]: specifies the sorting method
  • asc: ascending order
  • desc: descending order

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "sort": {
    "dp_pubdate": "desc"
  }
}

scope

This is a field for limiting the search target and results. The input format is as follows.

{
  "scope": {
    "[scope_target]": {
      "[scope_method]": (string|int|double|array)
    }
  }
}

• [scope_target]: specifies the search target to limit
  • Enter a document attribute or a variable in the ranking module
• [scope_method]: selects the search method to limit
  • exist/nexist: limits search results to documents that have/don’t have where the specified value for the specified document property exists/does not exist.
  • range/nrange: limits the search results to documents that exist/don't have a value in the specified range for the specified document property.
    • It is applied in a gte:lte manner. <Example> Excluding documents with specified attribute values between 1 and 1000 when input "nrange": [1, 1000]
  • gte, gt, lte, lt: limits search results to documents that have values within the specified range for the specified document property. (gte: greater or equal, gt: greater, lte: less than or equal to, lt: less)
    • To perform a search within a specific date range, you need to use it by converting it to Long type's timestamp format.
  • bit/nbit: limit search results to documents with true or false by calculating the specified bit value and document property.
  • bitmask: limit search results to true or false documents by doing a bitmask calculation using the specified bit value and document property.
  • contains/ncontains : targets the document properties with multi-type (muint32, muint64, mstring, etc.), and limits search results to documents that contain/do not contain the value specified in the specified document property.

The following shows examples of writing the scope field for each method to limit search.
<Examples> exist and nexist

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "scope": {
    "dp_docprop1": {
      "exist": 1,
      "nexist": [1,2,3,4,5],
    },
    "dp_docprop2": {
      "nexist": 5
    }
  }
}

<Examples> range and nrange

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "scope": {
    "dp_docprop1": {
      "range": ["1", "10"],
      "nrange": ["1", "10"]
    },
    "dp_docprop2": {
      "range": ["2", "5"]
    }
  }
}

<Examples> gte, gte, lte, lt

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "scope": {
    "dp_docprop": {
      "gte": "0",
      "gt": "0",
	  "lte": "1",
	  "lt": "1"
    }
  }
}

<Examples> bit, nbit, bitmask

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "scope": {
    "dp_docprop": {
      "bit": "11110000",
      "nbit": "10101010",
      "bitmask": "11110000"
    }
  }
}

<Examples> contains and ncontains

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "scope": {
    "dp_multi_docprop": {
      "contains": [1,2,3],
      // "contains" : "1,2,3",      
      "ncontains": [4,5,6]
      // "not contain" : "4,5,6",
    }
  }
}

key_scope

This is a field for key-restricted searches that restrict search targets and results based on the document's key (main section). The input format is as follows.

{
  "key_scope": {
    "[key_scope_method]": (string|array)
  }
}

• [key_scope_method]: selects the search method to limit for the document key
  • exist/nexist: limits search results to documents corresponding to/not corresponding to the specified document key.

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "key_scope": {
    "exist": "A017a75c_000000000001fca5990e8e04",
    "nexist": ["A017a75c_000000000001fca5990e8e10", "A017a75c_000000000001fca5990e8e20"]
  }
}

user_scope

You can perform a limited search by entering a scope formula directly into the field. The input format is as follows.

{
  "user_scope": (string)
}

• user_scope: enters scope formula in the form of ranking code
  • The entered formula is applied as an AND condition with the content of the scope parameter when searching.

<Example 1>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "user_scope": "(dp_like_cnt => 100) and (dp_like_cnt <= 600)"
}

<Example 2>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "user_scope": "(dp_grade == 1) or (dp_grade == 2)"
}

highlighting

This field is used for settings to highlight syntax for search queries. The input format is as follows.

  "highlighting": {
    "enable": (string|bool),
    "pre_tag": (string),
    "post_tag": (string),
    "[highlighting_option]": (string|bool)
  }

• enable: selects whether to highlight (default: true)
• pre_tag, post_tag: specifies tags for highlighting syntax to highlight terms matched in search results
  • If not specified, <b>, </b> will be used as default.
• highlighting_option: specifies options for highlighting syntax (default: false)
  • remove_html_tag: removes HTML tags when activated.
  • skip_html_tag: when activated, it highlights HTML tags or keeps characters contained in tags without transformation.
  • braket_as_tag: when activated, it regards everything between "<" and ">" as an HTML tag.
  • num_entity_as_char: when activated, it treats numeric entities such as "가" as characters.
    • It also handles highlighting by treating the entity as a character.
  • skip_char_entity: when activated, it emphasizes text entities or keeps the text it contains untransformed.
  • kata_to_hira: when activated, it treats Japanese Katakana and Hiragana characters that correspond to each other as the same character.
  • bold_sub_query: when activated, it highlights all partial keywords, even if it finds an exact match to the query.
  • bold_sub_english: when activated, even if a part of an English word matches a term, it is highlighted.
    <Example> when the term is "a", it emphasizes the first letter "a" of "about".
  • bold_sub_digit: when activated, even if a part of a number matches a term, it is highlighted.
    <Example> when the term is "1", it emphasizes the first number "1" of "12345".
  • bold_sub_hanja: when activated, it also highlights Chinese characters.

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "highlighting": {
    "enable": true,
    "pre_tag": "<b>",
    "post_tag": "</b>",
    "remove_html_tag": true,
    "skip_html_tag": true,
    "num_entity_as_char": false,
    "braket_as_tag": false,
    "skip_char_entity": true,
    "kata_to_hira": false,
    "bold_sub_query": false,
    "bold_sub_english": true,
    "bold_sub_digit": true,
    "bold_sub_hanja": false,
  }
}

display_section

This field specifies which sections to display in search results and how they are displayed.

• If you don't specify this field, it will show the results of the entire section.
• If you specify a section, it will display only information from the selected section.

The input format is as follows.

{
  "display_section": (string|array),
}

• display_section: specifies the section to be displayed in the search results and enables combination of multiple sections
  <Example> when you want to output only price and name as result: input "price, name"
  <Example> when you want to output the brand and name as one result: input "brand+name"

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "display_section": ["TITLE","BODY","CONTENTS","TITLE+BODY"],
  "display_section": "TITLE,BODY,CONTENTS,TITLE+BODY"
}

passage

This field specifies the method to extract search results.

• If you don't specify this field, it reads the results of the entire section.
• If you specify a section, only the results of the selected sections are read.

The input format is as follows.

{
  "passage": {
    "[section_name]": {
       "passage_type": (string),
       "passage_option": (string),
       "max_length": (string|int)
    }
  }
}

• [section_name]: specifies the section name and enables combination of multiple sections <Example> TITLE+BODY
• passage_type: specifies the method to extract passage
  • none: reads from the beginning of the section.
  • classic: reads around the query index term in the section.
• passage_option: specifies options to extract passage
• max_length: specifies length of passage extraction

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "passage": {
    "TITLE": {
       "passage_type": "classic",
       "passage_option": "mspcnt=1;rmtag=on;",
       "max_length": 400
    },
    "TITLE+BODY": {
       "passage_type": "classic",
       "passage_option": "mspcnt=1;rmtag=on;",
       "max_length": 500
    }
  }
}

aggregate

It is a field for summarized search. Calculates the specified property value of the searched document and displays the calculation result for each standard property. The input format is as follows.

{
  "aggregate": {
    "[docprop_name]": {
      "max": (string),
      "min": (string),
      "one": (string),
      "sum": (string)
    }
  }
}

• [docprop_name]: specifies the document properties that are the criteria for summary search
• max: specifies max operation target for summary search
• min: specifies min operation target for summary search
• one: specifies one operation target for summary search
• sum: specifies sum operation target for summary search
  • When the keyword '_1' is used, the number of summarized results is calculated.

<Example> In the Cloud Search example, search for the minimum value of the number of vehicles and price (dp_price) by vehicle type (dp_type)

{
  "aggregate": {
    "dp_type": {
      "sum": "_1",
      "min": "dp_price"
    }
  }
}

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "aggregate": {
    "dp_like_cnt": {
      "max": ["dp_like_cnt", "dp_dislike_cnt"],
      "min": ["dp_like_cnt", "dp_disklike_cnt"],
      "one": "dp_like_cnt",
      "sum": "_1"
    }
  }
}

ranking

It is a field for specifying ranks. Enter the registered ranking module name or directly enter the ranking code. The input format is as follows.

{
  "ranking": {
    "name": (string),
    "code": (string),
    "override_value": {
        "[ranking_value]" : (string|int|float)
    }
  }
}

<Example> Search by selecting a registered ranking module (clous)

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "ranking": {
    "name": "clous"
  }
}

<Example> Search by directly entering a ranking code

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "ranking": {
    "code": "overridable quality = 0.5; _relevance = 0.3 * qds + 0.7 * quality;",
    "override_value": {
        "quality": 1.0
    }
  }
}

result_processing

This is a field to set post-processing of search results. The input format is as follows.

{
  "result_processing": {
    "[section_name]": {
      "[result_processing_method]": (string|bool)
    }
  }
}

• [section_name]: specifies section
• [result_processing_method]: specifies post-processing method
  • remove_duplicate: removes passage duplication

<Example>

{
  "search": {
    "body_sgmt": {
      "main": {
        "query": "search",
      }
    }
  },
  "result_processing": {
    "BODY": {
      "remove_duplicate": true
    }
  }
}

setting

You can configure other search settings. The input format is as follows.

{
  "setting": {
    "search_timeout": (string|int),
    "ranking_value": (string|bool),
    "reuse_term_extractor": (string|bool),
    "log_level": (string|list),
  }
}

• search_timeout: specifies timeout value for search request
• ranking_value: specifies whether or not to expose the ranking variable value in the result
• reuse_term_extractor: specifies whether to save the term analyzer created in the term_extractor option of the search field to the server (default: false)
  • true: saves the term analyzer created at runtime through the term_extractor option on the server so that it can be used for the next request. (saves up to 50 in total)
  • false: uses the term analyzer created at runtime through the term_extractor option once and discards it.
  • It is an option that does not affect search results but does affect performance.
    • If you plan to build search queries using term_extractor options, be sure to enable them before receiving real traffic.
    • When testing, disable the option and test because the number of term analyzers may exceed the maximum number (50).

<Example>

{
  "setting": {
    "search_timeout": 30,
    "ranking_value": true,
    "reuse_term_extractor": true
  }
}

Enter in URI

Call the API by entering your search query into a URL.

• Enter it in the form of query string parameters in the form of JSONPath.
• Select HTTP GET as the method.
• Enable use by applying the format of the request body as it is.

start

Select the starting ranking of search results to be displayed. The default is 1, and the input format is:

?start=(string)

<Example>

?start=1

display

Select the number of search results to be displayed. The default is 20, and the input format is:

?display=(string)

<Example>

?display=20

result_format

Select the format of search results. The default is json, and the input format is:

?result_format=(string)

<Example>

?result_format=json

search

This parameter is required for searching. The input format is as follows.

?search.[index_name].[query_method].query=(string)
?search.[index_name].[query_method].type=(string)
?search.[index_name].[query_method].option=(string)
?search.[index_name].[query_method].ratio=(string)
?search.[index_name].[query_method].term_extractor=(string)

<Example>

?search.body_sgmt.main.query=search&search.body_sgmt.main.type=nterm&search.body_sgmt.main.option=and

sort

This is a parameter for setting criteria of search results. The input format is as follows.

?sort.[sort_target]=[sort_option]

<Example>

?sort.relevance=desc

scope

This is a parameter for limiting the search target and results. The input format is as follows.

?scope.[scope_target].[scope_method]=(string)

<Example>

?scope.dp_grade.exist=1
?scope.dp_pubdate.range=180403,180410
?scope.dp_price.gte=777

key_scope

This is a parameter for key-restricted searches that restrict search targets and results based on the document's key (main section). The input format is as follows.

?key_scope.[key_scope_method]=(string)

<Example>

?key_scope.exist=gdid_000000001
?key_scope.nexist=gdid_00000010

user_scope

You can perform a limited search by entering a scope formula directly. The input format is as follows.

?user_scope=(string)

<Example>

?user_scope=(dp_price > 400)
?user_scope=(dp_price >= 400) and (dp_price < 1000)
?user_scope=(dp_grade == 1) and (dp_grade == 2)

highlighting

This is a parameter is for settings to highlight syntax for search queries. The input format is as follows.

?highlighting.enable=(string)
?highlighting.pre_tag=(string)
?highlighting.post_tag=(string)
?highlighting.[highlighting_option]=(string)

<Example>

?highlighting.enable=true
?highlighting.pre_tag=<b>&highlighting.post_tag=</b>
?highlighting.bold_sub_digit=true

display_section

This parameter specifies which sections to display in search results and how they are displayed.

• If you don’t designate this parameter, it displays the results of the entire section.
• If you specify a section, it will display only information from the selected section.

The input format is as follows.

?display_section=(string)

<Example>

?display_section=BODY:TITLE

passage

This parameter specifies the method to extract search results.

• If you don’t designate this parameter, the results of all sections are read.
• If you specify a section, only the results of the selected sections are read.

The input format is as follows.

?passage.[section_name].passage_type=(string)
?passage.[section_name].passage_option=(string)
?passage.[section_name].max_length=(string)

<Example>

?passage.BODY.passage_type=classic
?passage.BODY.passage_option=mspcnt=1;rmtag=on;
?passage.BODY.max_length=400

aggregate

This is a parameter for summarized search. Displays the result of performing the specified operation on the specified field of the searched document. The input format is as follows.

?aggregate.[docprop_name].max=(string)
?aggregate.[docprop_name].min=(string)
?aggregate.[docprop_name].one=(string)
?aggregate.[docprop_name].sum=(string)

<Example>

?aggregate.dp_like_cnt.max=dp_like_cnt,dp_dislike_cnt
?aggregate.dp_like_cnt.min=dp_like_cnt,dp_type
?aggregate.dp_like_cnt.sum=_1

ranking

This is a parameter for specifying ranks. Enter the registered ranking module name or directly enter the ranking code. The input format is as follows.

?ranking.name=(string)
?ranking.code=(string)
?ranking.override_value.[ranking_value]=(string)

<Example>

?ranking.name=clous
?ranking.code=relevance = qds * 0.1;
?ranking.override_value.[ranking_value]=10.123

result_processing

This is a parameter for processing search results. The input format is as follows.

?result_processing.[section_name].[result_processing_method]=(string)

<Example>

?result_processing.TITLE.remove_duplicate=true

setting

You can configure other search settings. The input format is as follows.

?setting.transfer_timeout=(string)
?setting.search_timeout=(string)
?setting.use_df=(string)
?setting.reuse_term_extractor=(string)

<Example>

?setting.transfer_timeout=30
?setting.search_timeout=30
?setting.use_df=true
?setting.reuse_term_extractor=true