org.apache.hive.hplsql.Arguments Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hive-hplsql
There is a newer version: 4.0.1
/**
 * 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.hive.hplsql;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import org.apache.commons.cli.CommandLine;
import org.apache.commons.cli.GnuParser;
import org.apache.commons.cli.HelpFormatter;
import org.apache.commons.cli.Option;
import org.apache.commons.cli.Options;
import org.apache.commons.cli.OptionBuilder;
import org.apache.commons.cli.ParseException;

public class Arguments {
  private CommandLine commandLine;
  private Options options = new Options();
  
  String execString;
  String fileName;  
  String main;
  Map vars = new HashMap();
  
  @SuppressWarnings("static-access")
  Arguments() {
    // -e 'query'
    options.addOption(OptionBuilder
        .hasArg()
        .withArgName("quoted-query-string")
        .withDescription("HPL/SQL from command line")
        .create('e'));

    // -f 
    options.addOption(OptionBuilder
        .hasArg()
        .withArgName("filename")
        .withDescription("HPL/SQL from a file")
        .create('f'));    
    
    // -main entry_point_name
    options.addOption(OptionBuilder
        .hasArg()
        .withArgName("procname")
        .withDescription("Entry point (procedure or function name)")
        .create("main"));  
    
    // -hiveconf x=y
    options.addOption(OptionBuilder
        .withValueSeparator()
        .hasArgs(2)
        .withArgName("property=value")
        .withLongOpt("hiveconf")
        .withDescription("Value for given property")
        .create());
    
    // Substitution option -d, --define
    options.addOption(OptionBuilder
        .withValueSeparator()
        .hasArgs(2)
        .withArgName("key=value")
        .withLongOpt("define")
        .withDescription("Variable substitution e.g. -d A=B or --define A=B")
        .create('d'));

    // Substitution option --hivevar
    options.addOption(OptionBuilder
        .withValueSeparator()
        .hasArgs(2)
        .withArgName("key=value")
        .withLongOpt("hivevar")
        .withDescription("Variable substitution e.g. --hivevar A=B")
        .create());
    
    // [-version|--version]
    options.addOption(new Option("version", "version", false, "Print HPL/SQL version"));

    // [-trace|--trace]
    options.addOption(new Option("trace", "trace", false, "Print debug information"));
    
    // [-offline|--offline]
    options.addOption(new Option("offline", "offline", false, "Offline mode - skip SQL execution"));
    
    // [-H|--help]
    options.addOption(new Option("H", "help", false, "Print help information"));
  }
  
  /**
   * Parse the command line arguments
   */
  public boolean parse(String[] args) {
    try {
      commandLine = new GnuParser().parse(options, args);
      execString = commandLine.getOptionValue('e');
      fileName = commandLine.getOptionValue('f');
      main = commandLine.getOptionValue("main");
      Properties p = commandLine.getOptionProperties("hiveconf");
      for(String key : p.stringPropertyNames()) {
        vars.put(key, p.getProperty(key));
      }
      p = commandLine.getOptionProperties("hivevar");
      for(String key : p.stringPropertyNames()) {
        vars.put(key, p.getProperty(key));
      }
      p = commandLine.getOptionProperties("define");
      for(String key : p.stringPropertyNames()) {
        vars.put(key, p.getProperty(key));
      }
    } catch (ParseException e) {
      System.err.println(e.getMessage());
      return false;
    }
    return true;
  }
  
  /**
   * Get the value of execution option -e
   */
  public String getExecString() {
    return execString;
  }
  
  /**
   * Get the value of file option -f
   */
  public String getFileName() {
    return fileName;
  }
  
  /**
   * Get the value of -main option
   */
  public String getMain() {
    return main;
  }
  
  /**
   * Get the variables
   */
  public Map getVars() {
    return vars;
  }

  /**
   * Test whether version option is set
   */
  public boolean hasVersionOption() {
    if(commandLine.hasOption("version")) {
      return true;
    }
    return false;
  }
  
  /**
   * Test whether debug option is set
   */
  public boolean hasTraceOption() {
    if(commandLine.hasOption("trace")) {
      return true;
    }
    return false;
  }
  
  /**
   * Test whether offline option is set
   */
  public boolean hasOfflineOption() {
    if(commandLine.hasOption("offline")) {
      return true;
    }
    return false;
  }
  
  /**
   * Test whether help option is set
   */
  public boolean hasHelpOption() {
    if(commandLine.hasOption('H')) {
      return true;
    }
    return false;
  }
  
  /**
   * Print help information
   */
  public void printHelp() {
    new HelpFormatter().printHelp("hplsql", options);
  }
}