<label for="queries" class="col-sm-2 text-sm-right col-form-label"><la:message
                                                key="labels.related_query_queries"/></label>
                                        <div class="col-sm-10">
                                            <la:text styleId="queries" property="queries" styleClass="form-control"/>
                                        </div>

      "related_query" : {
        "properties" : {
          "createdBy" : {
            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "queries" : {
            "type" : "keyword"
          },
          "term" : {
            "type" : "keyword"
          },
          "updatedBy" : {
            "type" : "keyword"
          },

            cb.query().setTerm_Wildcard(wrapQuery(relatedQueryPager.term));
        }
        if (StringUtil.isNotBlank(relatedQueryPager.queries)) {
            cb.query().setQueries_Wildcard(wrapQuery(relatedQueryPager.queries));
        }
        // TODO Long, Integer, String supported only.

        // setup condition
        cb.query().addOrderBy_Term_Asc();

        requestBody.put(KEY_PROPERTY, keyProp);
        requestBody.put("queries", "query" + id);
        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("queries", "new_query");
        return updateMap;
    }

    @Test
    void crudTest() {

		"*" is a multiple character wildcard search.
		<pre>Fess*</pre>
		or
		<pre>Fe?s</pre>
	</dd>
	<dt>Range</dt>
	<dd>
		Range Queries allow one to match documents whose field(s) values are
		between the lower and upper bound specified by the Range Query. Range
		Queries can be inclusive or exclusive of the upper and lower bounds.
		If you want to find documents whose content_length fields have values

package org.codelibs.fess.app.web.api.admin.relatedquery;

import org.codelibs.fess.app.web.api.admin.BaseSearchBody;

public class SearchBody extends BaseSearchBody {

    public String term;

    public String queries;

    public static final String SMBSERVER_NAME = "*SMBSERVER     ";

    /**
     * A B node only broadcasts name queries. This is the default if a
     * nameserver such as WINS or Samba is not specified.
     */

    public static final int B_NODE = 0;

    /**
     * A Point-to-Point node, or P node, unicasts queries to a nameserver
     * only. Natrually the <code>jcifs.netbios.nameserver</code> property must
     * be set.

		// KMS Key APIs
		kmsRouter.Methods(http.MethodPost).Path(version+"/key/create").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSCreateKeyHandler))).Queries("key-id", "{key-id:.*}")
		kmsRouter.Methods(http.MethodGet).Path(version+"/key/list").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSListKeysHandler))).Queries("pattern", "{pattern:.*}")
		kmsRouter.Methods(http.MethodGet).Path(version + "/key/status").HandlerFunc(gz(httpTraceAll(kmsAPI.KMSKeyStatusHandler)))
	}

func (e *SelectStatement) IsAggregated() bool {
	return e.selectQProp.isAggregation
}

// AggregateResult - returns the aggregated result after all input
// records have been processed. Applies only to aggregation queries.
func (e *SelectStatement) AggregateResult(output Record) error {
	for i, expr := range e.selectAST.Expression.Expressions {
		v, err := expr.evalNode(nil, e.tableAlias)
		if err != nil {
			return err
		}

        final EditBody body = new EditBody();
        copyBeanToBean(entity, body, copyOp -> {
            copyOp.excludeNull();
            copyOp.exclude(Constants.QUERIES);
        });
        body.queries = stream(entity.getQueries()).get(stream -> stream.filter(StringUtil::isNotBlank).collect(Collectors.joining("\n")));
        return body;
    }