org.apache.blur.shell.QueryCommandHelper.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.blur.shell.QueryCommandHelper.java

Source

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.blur.shell;

import java.io.PrintWriter;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.blur.thrift.generated.BlurQuery;
import org.apache.blur.thrift.generated.Facet;
import org.apache.blur.thrift.generated.HighlightOptions;
import org.apache.blur.thrift.generated.Query;
import org.apache.blur.thrift.generated.ScoreType;
import org.apache.blur.thrift.generated.Selector;
import org.apache.blur.thrift.generated.SortField;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.CommandLineParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.ParseException;
import org.apache.commons.cli.PosixParser;

public class QueryCommandHelper {

    public static final String QUERY = "query";
    public static final String WIDTH = "width";
    public static final String SORT = "sort";
    public static final String FACET = "facet";
    public static final String ROW_ID = "rowId";
    public static final String MINIMUM_NUMBER_OF_RESULTS = "min";
    public static final String MAX_QUERY_TIME = "max";
    public static final String FETCH = "fetch";
    public static final String START = "start";
    public static final String DISABLE_ROW_QUERY = "disableRowQuery";
    public static final String SCORE_TYPE = "scoreType";
    public static final String RECORD_FILTER = "recordFilter";
    public static final String ROW_FILTER = "rowFilter";

    @SuppressWarnings("unchecked")
    public static BlurQuery getBlurQuery(CommandLine commandLine) {
        Option[] options = commandLine.getOptions();
        Query query = new Query();
        if (commandLine.hasOption(QUERY)) {
            String queryString = join(Arrays.asList(commandLine.getOptionValues(QUERY)), " ");
            query.setQuery(queryString);
        }
        if (commandLine.hasOption(DISABLE_ROW_QUERY)) {
            query.setRowQuery(false);
        }
        if (commandLine.hasOption(SCORE_TYPE)) {
            String scoreTypeStr = commandLine.getOptionValue(SCORE_TYPE);
            ScoreType scoreType = ScoreType.valueOf(scoreTypeStr.toUpperCase());
            query.setScoreType(scoreType);
        }
        if (commandLine.hasOption(RECORD_FILTER)) {
            String recordFilter = commandLine.getOptionValue(RECORD_FILTER);
            query.setRecordFilter(recordFilter);
        }
        if (commandLine.hasOption(ROW_FILTER)) {
            String rowFilter = commandLine.getOptionValue(ROW_FILTER);
            query.setRecordFilter(rowFilter);
        }

        // String recordFilter;
        // String rowFilter;
        // String rowId;
        // long start;
        // int fetch;
        // long maxQueryTime;
        // long minimumNumberOfResults;
        // List<Facet> facets;
        // List<SortField> sortFields;

        BlurQuery blurQuery = new BlurQuery();
        blurQuery.setQuery(query);
        Selector selector = new Selector(Main.selector);
        if (!query.isRowQuery()) {
            selector.setRecordOnly(true);
        }
        blurQuery.setSelector(selector);
        blurQuery.setCacheResult(false);
        blurQuery.setUseCacheIfPresent(false);

        if (commandLine.hasOption(START)) {
            String startStr = commandLine.getOptionValue(START);
            blurQuery.setStart(Long.parseLong(startStr));
        }
        if (commandLine.hasOption(FETCH)) {
            String fetchStr = commandLine.getOptionValue(FETCH);
            blurQuery.setFetch(Integer.parseInt(fetchStr));
        }
        if (commandLine.hasOption(MAX_QUERY_TIME)) {
            String maxQueryTimeStr = commandLine.getOptionValue(MAX_QUERY_TIME);
            blurQuery.setMaxQueryTime(Long.parseLong(maxQueryTimeStr));
        }
        if (commandLine.hasOption(MINIMUM_NUMBER_OF_RESULTS)) {
            String minNumbResultsStr = commandLine.getOptionValue(MINIMUM_NUMBER_OF_RESULTS);
            blurQuery.setMinimumNumberOfResults(Long.parseLong(minNumbResultsStr));
        }
        if (commandLine.hasOption(ROW_ID)) {
            String rowId = commandLine.getOptionValue(ROW_FILTER);
            blurQuery.setRowId(rowId);
        }
        List<Facet> facets = new ArrayList<Facet>();
        for (Option option : options) {
            if (option.getOpt().equals(FACET)) {
                List<String> valuesList = option.getValuesList();
                Facet facet = new Facet();
                facet.setQueryStr(join(valuesList, " "));
                facets.add(facet);
            }
        }
        if (!facets.isEmpty()) {
            blurQuery.setFacets(facets);
        }

        List<SortField> sortFields = new ArrayList<SortField>();
        for (Option option : options) {
            if (option.getOpt().equals(SORT)) {
                List<String> valuesList = option.getValuesList();
                if (valuesList.size() == 2) {
                    sortFields.add(new SortField(valuesList.get(0), valuesList.get(1), false));
                } else if (valuesList.size() == 3) {
                    sortFields.add(new SortField(valuesList.get(0), valuesList.get(1),
                            Boolean.parseBoolean(valuesList.get(2))));
                } else {
                    throw new RuntimeException("Sort take 2 or 3 parameters.");
                }
            }
        }
        if (!sortFields.isEmpty()) {
            blurQuery.setSortFields(sortFields);
        }

        if (Main.highlight) {
            blurQuery.getSelector().setHighlightOptions(new HighlightOptions());
        }

        return blurQuery;
    }

    private static String join(List<String> argList, String sep) {
        StringBuilder builder = new StringBuilder();
        for (String s : argList) {
            if (builder.length() != 0) {
                builder.append(sep);
            }
            builder.append(s);
        }
        return builder.toString();
    }

    @SuppressWarnings("static-access")
    public static CommandLine parse(String[] otherArgs, Writer out, String usage) {
        Options options = new Options();
        options.addOption(OptionBuilder.hasArgs().withDescription("* Query string.").isRequired().create(QUERY));
        options.addOption(OptionBuilder.withDescription("Disables row query. (Enabled by default)")
                .create(DISABLE_ROW_QUERY));
        options.addOption(OptionBuilder.hasArg().withArgName(SCORE_TYPE)
                .withDescription("Specify the scoring type.").create(SCORE_TYPE));
        options.addOption(OptionBuilder.hasArgs().withArgName(ROW_FILTER).withDescription("Specify row filter.")
                .create(ROW_FILTER));
        options.addOption(OptionBuilder.hasArgs().withArgName(RECORD_FILTER)
                .withDescription("Specify record filter.").create(RECORD_FILTER));
        options.addOption(OptionBuilder.hasArg().withArgName(START)
                .withDescription("Specify the starting position (paging).").create(START));
        options.addOption(OptionBuilder.hasArg().withArgName(FETCH)
                .withDescription("Specify the number of elements to fetch in a single page.").create(FETCH));
        options.addOption(OptionBuilder.hasArg().withArgName(MAX_QUERY_TIME)
                .withDescription("Specify the maximum amount of time to allow query to execute.")
                .create(MAX_QUERY_TIME));
        options.addOption(OptionBuilder.hasArg().withArgName(MINIMUM_NUMBER_OF_RESULTS)
                .withDescription("Specify the minimum number of results required before returning from query.")
                .create(MINIMUM_NUMBER_OF_RESULTS));
        options.addOption(OptionBuilder.hasArg().withArgName(ROW_ID)
                .withDescription(
                        "Specify the rowId to execute the query against (this reduces the spray to other shards).")
                .create(ROW_ID));
        options.addOption(OptionBuilder.withArgName(FACET).hasArgs()
                .withDescription("Specify facet to be executed with this query.").create(FACET));
        options.addOption(OptionBuilder.withArgName(SORT).hasArgs()
                .withDescription("Specify a sort to be applied to this query <family> <column> [<reverse>].")
                .create(SORT));
        options.addOption(OptionBuilder.withDescription("Displays help for this command.").create("h"));
        options.addOption(OptionBuilder.withArgName(WIDTH).hasArgs()
                .withDescription("Specify max column width for display.").create(WIDTH));

        CommandLineParser parser = new PosixParser();
        CommandLine cmd = null;
        try {
            cmd = parser.parse(options, otherArgs);
            if (cmd.hasOption("h")) {
                HelpFormatter formatter = new HelpFormatter();
                PrintWriter pw = new PrintWriter(out, true);
                formatter.printHelp(pw, HelpFormatter.DEFAULT_WIDTH, usage, null, options,
                        HelpFormatter.DEFAULT_LEFT_PAD, HelpFormatter.DEFAULT_DESC_PAD, null, false);
                return null;
            }
        } catch (ParseException e) {
            HelpFormatter formatter = new HelpFormatter();
            PrintWriter pw = new PrintWriter(out, true);
            formatter.printHelp(pw, HelpFormatter.DEFAULT_WIDTH, usage, null, options,
                    HelpFormatter.DEFAULT_LEFT_PAD, HelpFormatter.DEFAULT_DESC_PAD, null, false);
            return null;
        }
        return cmd;
    }
}