Get the query options string to use for this query.
559201
def __query_options(self):
        """"""
        options = 0
        if self.__tailable:
            options |= _QUERY_OPTIONS["tailable_cursor"]
        if self.__slave_okay or self.__pool._slave_okay:
            options |= _QUERY_OPTIONS["slave_okay"]
        if not self.__timeout:
            options |= _QUERY_OPTIONS["no_timeout"]
        return options
704400
def getQueryParams(url):
    """"""
    query = urlsplit(url)[3]
    out.debug(u'Extracting query parameters from %r (%r)...' % (url, query))
    return cgi.parse_qs(query)
1013653
def parse_options(options) # :nodoc
      options[:max_results] ||=  25
      options[:order_by] ||= 'startTime' # other option is 'updated'
      options[:expand_recurring_events] ||= true
      query_string = "&orderBy=#{options[:order_by]}"
      query_string << "&maxResults=#{options[:max_results]}"
      query_string << "&singleEvents=#{options[:expand_recurring_events]}"
      query_string << "&q=#{options[:query]}" unless options[:query].nil?
      query_string
    end
41991
def _getParameters(self):
        """"""
        param = self.query._getParameters()                   
        param[self.__key] =  self.__value
        return param
230468
public R textQueryString(String query, TextQueryString options) {
    peekExprList().textQueryString(query, options);
    return root;
  }
478075
private String getQueryParam() {

        final String param = parseOptionalStringValue(XML_ELEMENT_QUERYPARAM);
        if (param == null) {
            return DEFAULT_QUERY_PARAM;
        } else {
            return param;
        }
    }
659900
def _parse_api_options(self, options, query_string=False):
        
        api_options = self._select_options(options, self.API_OPTIONS)
        if query_string:
            # Prefix all options with "opt_"
            query_api_options = {}
            for key in api_options:
                # Transform list/tuples into comma separated list
                if isinstance(api_options[key], (list, tuple)):
                    query_api_options[
                        'opt_' + key] = ','.join(api_options[key])
                else:
                    query_api_options[
                        'opt_' + key] = api_options[key]
            return query_api_options
        else:
            return api_options
1130138
def _query_select_options(self, query, select_columns=None):
        
        if select_columns:
            _load_options = list()
            for column in select_columns:
                if "." in column:
                    model_relation = self.get_related_model(column.split(".")[0])
                    if not self.is_model_already_joinded(query, model_relation):
                        query = query.join(model_relation)
                    _load_options.append(
                        Load(model_relation).load_only(column.split(".")[1])
                    )
                else:
                    if not self.is_relation(column) and not hasattr(
                        getattr(self.obj, column), "__call__"
                    ):
                        _load_options.append(Load(self.obj).load_only(column))
                    else:
                        _load_options.append(Load(self.obj))
            query = query.options(*tuple(_load_options))
        return query
1252697
public @NotNull OptionalInt findOptionalInt(@NotNull SqlQuery query) {
        Optional<Integer> value = findOptional(Integer.class, query);
        return value.isPresent() ? OptionalInt.of(value.get()) : OptionalInt.empty();
    }
1110944
@Override
  protected Options getOptions() {
    final Options options = super.getOptions();

    final Option filenameOption =
        new Option("k", "the keyword to search for in the page  [required]");
    filenameOption.setArgName("KEYWORD");
    filenameOption.setLongOpt("keyword");
    filenameOption.setRequired(true);
    filenameOption.setArgs(1);

    options.addOption(filenameOption);

    return options;

  }
102803
private String getPathSelectString() {
        String queryString = "SELECT " + Constants.DB_TABLE_REQUEST_RESPONSE + "." + Constants.GENERIC_CLIENT_UUID +
            "," + Constants.DB_TABLE_PATH + "." + Constants.GENERIC_ID +
            "," + Constants.PATH_PROFILE_PATHNAME +
            "," + Constants.PATH_PROFILE_ACTUAL_PATH +
            "," + Constants.PATH_PROFILE_BODY_FILTER +
            "," + Constants.PATH_PROFILE_GROUP_IDS +
            "," + Constants.DB_TABLE_PATH + "." + Constants.PATH_PROFILE_PROFILE_ID +
            "," + Constants.PATH_PROFILE_PATH_ORDER +
            "," + Constants.REQUEST_RESPONSE_REPEAT_NUMBER +
            "," + Constants.REQUEST_RESPONSE_REQUEST_ENABLED +
            "," + Constants.REQUEST_RESPONSE_RESPONSE_ENABLED +
            "," + Constants.PATH_PROFILE_CONTENT_TYPE +
            "," + Constants.PATH_PROFILE_REQUEST_TYPE +
            "," + Constants.PATH_PROFILE_GLOBAL +
            " FROM " + Constants.DB_TABLE_PATH +
            " JOIN " + Constants.DB_TABLE_REQUEST_RESPONSE +
            " ON " + Constants.DB_TABLE_PATH + "." + Constants.GENERIC_ID +
            "=" + Constants.DB_TABLE_REQUEST_RESPONSE + "." + Constants.REQUEST_RESPONSE_PATH_ID +
            " AND " + Constants.DB_TABLE_REQUEST_RESPONSE + "." + Constants.GENERIC_CLIENT_UUID + " = ?";

        return queryString;
    }
1201028
def _options_string(self):
        
        if len(self.options) > 0:
            s = ""
            for op in self.options:
                if self._sized_op:
                    s += "{:s}={:s} ".format(*map(str, op))
                else:
                    s += "{:s} ".format(str(op))
            return s.strip()
        else:
            return ""
155720
public String toQueryString() {
        StringBuilder sb = new StringBuilder();
        boolean firstParam = true;
        for (int i = 0; i < params.length; i++) {
            if (params[i] == null) {
                i++;
                continue;
            }

            boolean even = i % 2 == 0;
            if (even) {
                if (!firstParam) {
                    sb.append("&");
                }
            }
            sb.append(params[i]);
            firstParam = false;
            if (even) {
                sb.append('=');
            }
        }
        return sb.toString();
    }
226718
def parse_options():
    

    parser = optparse.OptionParser(usage=USAGE, version=VERSION)

    parser.add_option("-q", "--query",
            action="store", type="string", default="", dest="query",
            help="SPARQL query string")

    parser.add_option("-f", "--format",
            action="store", type="string", default="JSON", dest="format",
            help="Results format: one of JSON, XML")

    parser.add_option("-d", "--describe",
            action="store", type="string", default="", dest="describe",
            help="Describe Query: just pass a URI")

    parser.add_option("-a", "--alltriples",
            action="store", type="string", default="", dest="alltriples",
            help="Get all available triples for a URI")

    parser.add_option("-o", "--ontology",
            action="store_true", default=False, dest="ontology",
            help="Get all entities of type owl:Class - aka the ontology")

    opts, args = parser.parse_args()

    if len(args) > 0:  #dont take no args
        parser.print_help()
        raise SystemExit, 1
    if not (opts.query or opts.describe or opts.alltriples or opts.ontology):
        parser.print_help()
        raise SystemExit, 1
    return opts, args
552750
public String[] getOptions() {
    int       	i;
    Vector    	result;
    String	tmpStr;

    result = new Vector();

    for (i = 0; i < m_Parameters.length; i++) {
      result.add("-search");
      tmpStr =   m_Parameters[i].getClass().getName() + " "
               + Utils.joinOptions(m_Parameters[i].getOptions());
      result.add(tmpStr);
    }

    return (String[]) result.toArray(new String[result.size()]);
  }
320931
function toQueryStringWithOptions(obj, opts) {
  opts = opts || {};
  if (isUndefined(opts.separator)) {
    opts.separator = '_';
  }
  return toQueryString(obj, opts.deep, opts.transform, opts.prefix || '', opts.separator);
}
294991
public function getQueryString()
    {
        $qs = Request::normalizeQueryString($this->requestStack->getCurrentRequest()->server->get('QUERY_STRING'));

        return '' === $qs ? null : $qs;
    }