* 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.

*/

* Configurable state used by Sqoop tools.

*/

  public static final Log LOG = LogFactory.getLog(SqoopOptions.class.getName());

  /**

   * Set to true in configuration if you want to put db passwords

   * in the metastore.

   */

  public static final String METASTORE_PASSWORD_KEY =

      "sqoop.metastore.client.record.password";

  // Default hive and hcat locations.

  public static final String DEF_HIVE_HOME = "/usr/lib/hive";

  public static final String DEF_HCAT_HOME = "/usr/lib/hive-hcatalog";

  public static final String DEF_HCAT_HOME_OLD = "/usr/lib/hcatalog";

  public static final boolean METASTORE_PASSWORD_DEFAULT = false;

  /**

   * Thrown when invalid cmdline options are given.

   */

  @SuppressWarnings("serial")

  public static class InvalidOptionsException extends Exception {

    private String message;

    public InvalidOptionsException(final String msg) {

      this.message = msg;

    }

    public String getMessage() {

      return message;

    }

    public String toString() {

      return getMessage();

    }

  }

  // TODO(aaron): Adding something here? Add a setter and a getter.  Add a

  // default value in initDefaults() if you need one.  If this value needs to

  // be serialized in the metastore, it should be marked with

  // @StoredAsProperty(), if it is an int, long, boolean, String, or Enum.

  // Arrays and other "special" types should be added directly to the

  // loadProperties() and writeProperties() methods. Then add command-line

  // arguments in the appropriate tools. The names of all command-line args

  // are stored as constants in BaseSqoopTool.

  @StoredAsProperty("verbose") private boolean verbose;

  @StoredAsProperty("mapreduce.job.name") private String mapreduceJobName;

  @StoredAsProperty("db.connect.string") private String connectString;

  @StoredAsProperty("db.table") private String tableName;

  private String [] columns; // Array stored as db.column.list.

  @StoredAsProperty("db.username") private String username;

  @StoredAsProperty("db.export.staging.table") private String stagingTableName;

  @StoredAsProperty("db.clear.staging.table") private boolean clearStagingTable;

  @StoredAsProperty("db.export.call") private String call;

  private Properties connectionParams; //Properties stored as db.connect.params

  // May not be serialized, based on configuration.

  // db.require.password is used to determine whether 'some' password is

  // used. If so, it is stored as 'db.password'.

  private String password;

  // This represents path to a file on ${user.home} containing the password

  // with 400 permissions so its only readable by user executing the tool

  @StoredAsProperty("db.password.file") private String passwordFilePath;

  @StoredAsProperty("null.string") private String nullStringValue;

  @StoredAsProperty("input.null.string") private String inNullStringValue;

  @StoredAsProperty("null.non-string") private String nullNonStringValue;

  @StoredAsProperty("input.null.non-string")

      private String inNullNonStringValue;

  @StoredAsProperty("codegen.output.dir") private String codeOutputDir;

  @StoredAsProperty("codegen.compile.dir") private String jarOutputDir;

  // Boolean specifying whether jarOutputDir is a nonce tmpdir (true), or

  // explicitly set by the user (false). If the former, disregard any value

  // for jarOutputDir saved in the metastore.

  @StoredAsProperty("codegen.auto.compile.dir") private boolean jarDirIsAuto;

  private String hadoopMapRedHome; // not serialized to metastore.

  @StoredAsProperty("db.split.column") private String splitByCol;

  @StoredAsProperty("db.where.clause") private String whereClause;

  @StoredAsProperty("db.query") private String sqlQuery;

  @StoredAsProperty("db.query.boundary") private String boundaryQuery;

  @StoredAsProperty("jdbc.driver.class") private String driverClassName;

  @StoredAsProperty("hdfs.warehouse.dir") private String warehouseDir;

  @StoredAsProperty("hdfs.target.dir") private String targetDir;

  @StoredAsProperty("hdfs.append.dir") private boolean append;

  @StoredAsProperty("hdfs.delete-target.dir") private boolean delete;

  @StoredAsProperty("hdfs.file.format") private FileLayout layout;

  @StoredAsProperty("direct.import") private boolean direct; // "direct mode."

  @StoredAsProperty("db.batch") private boolean batchMode;

  private String tmpDir; // where temp data goes; usually /tmp; not serialized.

  private String hiveHome; // not serialized to metastore.

  @StoredAsProperty("hive.import") private boolean hiveImport;

  @StoredAsProperty("hive.overwrite.table") private boolean overwriteHiveTable;

  @StoredAsProperty("hive.fail.table.exists")

  private boolean failIfHiveTableExists;

  @StoredAsProperty("hive.table.name") private String hiveTableName;

  @StoredAsProperty("hive.database.name") private String hiveDatabaseName;

  @StoredAsProperty("hive.drop.delims") private boolean hiveDropDelims;

  @StoredAsProperty("hive.delims.replacement")

  private String hiveDelimsReplacement;

  @StoredAsProperty("hive.partition.key") private String hivePartitionKey;

  @StoredAsProperty("hive.partition.value") private String hivePartitionValue;

  @StoredAsProperty("hcatalog.table.name")

  private String hCatTableName;

  @StoredAsProperty("hcatalog.database.name")

  private String hCatDatabaseName;

  @StoredAsProperty("hcatalog.create.table")

  private boolean hCatCreateTable;

  @StoredAsProperty("hcatalog.storage.stanza")

  private String hCatStorageStanza;

  private String hCatHome; // not serialized to metastore.

  private boolean skipDistCache;

  @StoredAsProperty("hcatalog.partition.keys")

    private String hCatalogPartitionKeys;

  @StoredAsProperty("hcatalog.partition.values")

    private String hCatalogPartitionValues;

  // User explicit mapping of types

  private Properties mapColumnJava; // stored as map.colum.java

  private Properties mapColumnHive; // stored as map.column.hive

  // An ordered list of column names denoting what order columns are

  // serialized to a PreparedStatement from a generated record type.

  // Not serialized to metastore.

  private String [] dbOutColumns;

  // package to prepend to auto-named classes.

  @StoredAsProperty("codegen.java.packagename") private String packageName;

  // package+class to apply to individual table import.

  // also used as an *input* class with existingJarFile.

  @StoredAsProperty("codegen.java.classname") private String className;

  // Name of a jar containing existing table definition

  // class to use.

  @StoredAsProperty("codegen.jar.file") private String existingJarFile;

  @StoredAsProperty("mapreduce.num.mappers") private int numMappers;

  @StoredAsProperty("enable.compression") private boolean useCompression;

  @StoredAsProperty("compression.codec") private String compressionCodec;

  // In direct mode, open a new stream every X bytes.

  @StoredAsProperty("import.direct.split.size") private long directSplitSize;

  // Max size of an inline LOB; larger LOBs are written

  // to external files on disk.

  @StoredAsProperty("import.max.inline.lob.size") private long maxInlineLobSize;

  // Max number 'n' of rows to fetch from the

  // database when more rows are needed.

  @StoredAsProperty("import.fetch.size") private Integer fetchSize;

  // HDFS path to read from when performing an export

  @StoredAsProperty("export.source.dir") private String exportDir;

  // Column to use for the WHERE clause in an UPDATE-based export.

  @StoredAsProperty("export.update.col") private String updateKeyCol;

  @StoredAsProperty("export.new.update") private UpdateMode updateMode;

  private DelimiterSet inputDelimiters; // codegen.input.delimiters.

  private DelimiterSet outputDelimiters; // codegen.output.delimiters.

  private boolean areOutputDelimsManuallySet;

  private boolean areInputDelimsManuallySet;

  private Configuration conf;

  public static final int DEFAULT_NUM_MAPPERS = 4;

  private String [] extraArgs;

  // HBase table to import into.

  @StoredAsProperty("hbase.table") private String hbaseTable;

  // Column family to prepend to inserted cols.

  @StoredAsProperty("hbase.col.family") private String hbaseColFamily;

  // Column of the input to use as the row key.

  @StoredAsProperty("hbase.row.key.col") private String hbaseRowKeyCol;

  // if true, bulk loading will be used.

  @StoredAsProperty("hbase.bulk.load.enabled") private boolean hbaseBulkLoadEnabled;

  // if true, create tables/col families.

  @StoredAsProperty("hbase.create.table") private boolean hbaseCreateTable;

  // col to filter on for incremental imports.

  @StoredAsProperty("incremental.col") private String incrementalTestCol;

  // incremental import mode we're using.

  @StoredAsProperty("incremental.mode")

  private IncrementalMode incrementalMode;

  // What was the last-imported value of incrementalTestCol?

  @StoredAsProperty("incremental.last.value")

  private String incrementalLastValue;

  // exclude these tables when importing all tables.

  @StoredAsProperty("import.all_tables.exclude")

  private String allTablesExclude;

  // HDFS paths for "old" and "new" datasets in merge tool.

  @StoredAsProperty("merge.old.path") private String mergeOldPath;

  @StoredAsProperty("merge.new.path") private String mergeNewPath;

  // "key" column for the merge operation.

  @StoredAsProperty("merge.key.col") private String mergeKeyCol;

  // Accumulo home directory

  private String accumuloHome; // not serialized to metastore.

  // Zookeeper home directory

  private String zookeeperHome; // not serialized to metastore.

  // Accumulo table to import into.

  @StoredAsProperty("accumulo.table") private String accumuloTable;

  // Column family to prepend to inserted cols.

  @StoredAsProperty("accumulo.col.family") private String accumuloColFamily;

  // Column of the input to use as the row key.

  @StoredAsProperty("accumulo.row.key.col") private String accumuloRowKeyCol;

  //

  // Visibility token to be applied to each row imported.

  @StoredAsProperty("accumulo.visibility") private String accumuloVisibility;

  // Size of the write buffer.

  @StoredAsProperty("accumulo.batch.size")

  private long accumuloBatchSize;

  // Maximum latency for batch writer.

  @StoredAsProperty("accumulo.max.latency")

  private long accumuloMaxLatency;

  // if true, create table.

  @StoredAsProperty("accumulo.create.table")

  private boolean accumuloCreateTable;

  // Accumulo user name

  @StoredAsProperty("accumulo.user") private String accumuloUser;

  // Accumulo password

  @StoredAsProperty("accumulo.password") private String accumuloPassword;

  // Accumulo instance

  @StoredAsProperty("accumulo.instance") private String accumuloInstance;

  // Accumulo zookeeper

  @StoredAsProperty("accumulo.zookeepers") private String accumuloZookeepers;

  // Relaxed Isolation

  @StoredAsProperty("relaxed.isolation") private boolean relaxedIsolation;

  // These next two fields are not serialized to the metastore.

  // If this SqoopOptions is created by reading a saved job, these will

  // be populated by the JobStorage to facilitate updating the same

  // job.

  private String jobName;

  private Map<String, String> jobStorageDescriptor;

  // If we restore a job and then allow the user to apply arguments on

  // top, we retain the version without the arguments in a reference to the

  // 'parent' SqoopOptions instance, here.

  private com.cloudera.sqoop.SqoopOptions parent;

  // Nonce directory name. Generate one per process, lazily, if

  // getNonceJarDir() is called. Not recorded in metadata. This is used as

  // a temporary holding area for compilation work done by this process.

  private static String curNonce;

  // the connection manager fully qualified class name

  @StoredAsProperty("connection.manager") private String connManagerClassName;

  // The currently active tool. (Not saved in properties)

  // Used to pass the SqoopTool instance in to mapreduce job configuration

  // (JobBase, etc).

  private SqoopTool activeSqoopTool;

  // Flag to determine if data copied needs to be validated against the source

  private boolean isValidationEnabled;

  // These take FQCN as input, convert them to Class in light of failing early

  private Class validatorClass; // Class for the validator implementation.

  private Class validationThresholdClass; // ValidationThreshold implementation

  private Class validationFailureHandlerClass; // FailureHandler implementation

  public SqoopOptions() {

    initDefaults(null);

  }

  public SqoopOptions(Configuration conf) {

    initDefaults(conf);

  }

  /**

   * Alternate SqoopOptions interface used mostly for unit testing.

   * @param connect JDBC connect string to use

   * @param table Table to read

   */

  public SqoopOptions(final String connect, final String table) {

    initDefaults(null);

    this.connectString = connect;

    this.tableName = table;

  }

  private boolean getBooleanProperty(Properties props, String propName,

      boolean defaultValue) {

    String str = props.getProperty(propName,

        Boolean.toString(defaultValue)).toLowerCase();

    return "true".equals(str) || "yes".equals(str) || "1".equals(str);

  }

  private long getLongProperty(Properties props, String propName,

      long defaultValue) {

    String str = props.getProperty(propName,

        Long.toString(defaultValue)).toLowerCase();

    try {

      return Long.parseLong(str);

    } catch (NumberFormatException nfe) {

      LOG.warn("Could not parse integer value for config parameter "

          + propName);

      return defaultValue;

    }

  }

  private int getIntProperty(Properties props, String propName,

      int defaultVal) {

    long longVal = getLongProperty(props, propName, defaultVal);

    return (int) longVal;

  }

  private char getCharProperty(Properties props, String propName,

      char defaultVal) {

    int intVal = getIntProperty(props, propName, (int) defaultVal);

    return (char) intVal;

  }

  private DelimiterSet getDelimiterProperties(Properties props,

      String prefix, DelimiterSet defaults) {

    if (null == defaults) {

      defaults = new DelimiterSet();

    }

    char field = getCharProperty(props, prefix + ".field",

        defaults.getFieldsTerminatedBy());

    char record = getCharProperty(props, prefix + ".record",

        defaults.getLinesTerminatedBy());

    char enclose = getCharProperty(props, prefix + ".enclose",

        defaults.getEnclosedBy());

    char escape = getCharProperty(props, prefix + ".escape",

        defaults.getEscapedBy());

    boolean required = getBooleanProperty(props, prefix +".enclose.required",

        defaults.isEncloseRequired());

    return new DelimiterSet(field, record, enclose, escape, required);

  }

  private void setDelimiterProperties(Properties props,

      String prefix, DelimiterSet values) {

    putProperty(props, prefix + ".field",

        Integer.toString((int) values.getFieldsTerminatedBy()));

    putProperty(props, prefix + ".record",

        Integer.toString((int) values.getLinesTerminatedBy()));

    putProperty(props, prefix + ".enclose",

        Integer.toString((int) values.getEnclosedBy()));

    putProperty(props, prefix + ".escape",

        Integer.toString((int) values.getEscapedBy()));

    putProperty(props, prefix + ".enclose.required",

        Boolean.toString(values.isEncloseRequired()));

  }

  /** Take a comma-delimited list of input and split the elements

   * into an output array. */

  private String [] listToArray(String strList) {

    return strList.split(",");

  }

  private String arrayToList(String [] array) {

    if (null == array) {

      return null;

    }

    StringBuilder sb = new StringBuilder();

    boolean first = true;

    for (String elem : array) {

      if (!first) {

        sb.append(",");

      }

      sb.append(elem);

      first = false;

    }

    return sb.toString();

  }

  /**

   * A put() method for Properties that is tolerent of 'null' values.

   * If a null value is specified, the property is unset.

   */

  private void putProperty(Properties props, String k, String v) {

    if (null == v) {

      props.remove(k);

    } else {

      props.setProperty(k, v);

    }

  }

  /**

   * Given a property prefix that denotes a set of numbered properties,

   * return an array containing all the properties.

   *

   * For instance, if prefix is "foo", then return properties "foo.0",

   * "foo.1", "foo.2", and so on as an array. If no such properties

   * exist, return 'defaults'.

   */

  private String [] getArgArrayProperty(Properties props, String prefix,

      String [] defaults) {

    int cur = 0;

    ArrayList<String> al = new ArrayList<String>();

    while (true) {

      String curProp = prefix + "." + cur;

      String curStr = props.getProperty(curProp, null);

      if (null == curStr) {

        break;

      }

      al.add(curStr);

      cur++;

    }

    if (cur == 0) {

      // Couldn't find an array here; return the defaults.

      return defaults;

    }

    return al.toArray(new String[0]);

  }

  private void setArgArrayProperties(Properties props, String prefix,

      String [] values) {

    if (null == values) {

      return;

    }

    for (int i = 0; i < values.length; i++) {

      putProperty(props, prefix + "." + i, values[i]);

    }

  }

  /**

   * This method encodes the property key values found in the provided

   * properties instance <tt>values</tt> into another properties instance

   * <tt>props</tt>. The specified <tt>prefix</tt> is used as a namespace

   * qualifier for keys when inserting. This allows easy introspection of the

   * property key values in <tt>props</tt> instance to later separate out all

   * the properties that belong to the <tt>values</tt> instance.

   * @param props the container properties instance

   * @param prefix the prefix for qualifying contained property keys.

   * @param values the contained properties instance, all of whose elements will

   *               be added to the container properties instance.

   *

   * @see #getPropertiesAsNetstedProperties(Properties, String)

   */

  private void setPropertiesAsNestedProperties(Properties props,

          String prefix, Properties values) {

    String nestedPropertyPrefix = prefix + ".";

    if (null == values || values.size() == 0) {

      Iterator<String> it = props.stringPropertyNames().iterator();

      while (it.hasNext()) {

        String name = it.next();

        if (name.startsWith(nestedPropertyPrefix)) {

          props.remove(name);

        }

      }

    } else {

      Iterator<String> it = values.stringPropertyNames().iterator();

      while (it.hasNext()) {

        String name = it.next();

        putProperty(props,

                nestedPropertyPrefix + name, values.getProperty(name));

      }

    }

  }

  /**

   * This method decodes the property key values found in the provided

   * properties instance <tt>props</tt> that have keys beginning with the

   * given prefix. Matching elements from this properties instance are modified

   * so that their prefix is dropped.

   * @param props the properties container

   * @param prefix the prefix qualifying properties that need to be removed

   * @return a new properties instance that contains all matching elements from

   * the container properties.

   */

  private Properties getPropertiesAsNetstedProperties(

          Properties props, String prefix) {

    Properties nestedProps = new Properties();

    String nestedPropertyPrefix = prefix + ".";

    int index = nestedPropertyPrefix.length();

    if (props != null && props.size() > 0) {

      Iterator<String> it = props.stringPropertyNames().iterator();

      while (it.hasNext()) {

        String name = it.next();

        if (name.startsWith(nestedPropertyPrefix)){

          String shortName = name.substring(index);

          nestedProps.put(shortName, props.get(name));

        }

      }

    }

    return nestedProps;

  }

  @SuppressWarnings("unchecked")

  /**

   * Given a set of properties, load this into the current SqoopOptions

   * instance.

   */

  public void loadProperties(Properties props) {

    try {

      Field [] fields = SqoopOptions.class.getDeclaredFields();

      for (Field f : fields) {

        if (f.isAnnotationPresent(StoredAsProperty.class)) {

          Class typ = f.getType();

          StoredAsProperty storedAs = f.getAnnotation(StoredAsProperty.class);

          String propName = storedAs.value();

          if (typ.equals(int.class)) {

            f.setInt(this,

                getIntProperty(props, propName, f.getInt(this)));

          } else if (typ.equals(boolean.class)) {

            f.setBoolean(this,

                getBooleanProperty(props, propName, f.getBoolean(this)));

          } else if (typ.equals(long.class)) {

            f.setLong(this,

                getLongProperty(props, propName, f.getLong(this)));

          } else if (typ.equals(String.class)) {

            f.set(this, props.getProperty(propName, (String) f.get(this)));

          } else if (typ.equals(Integer.class)) {

            String value = props.getProperty(

                propName,

                f.get(this) == null ? "null" : f.get(this).toString());

            f.set(this, value.equals("null") ? null : new Integer(value));

          } else if (typ.isEnum()) {

            f.set(this, Enum.valueOf(typ,

                props.getProperty(propName, f.get(this).toString())));

          } else {

            throw new RuntimeException("Could not retrieve property "

                + propName + " for type: " + typ);

          }

        }

      }

    } catch (IllegalAccessException iae) {

      throw new RuntimeException("Illegal access to field in property setter",

          iae);

    }

    // Now load properties that were stored with special types, or require

    // additional logic to set.

    loadPasswordProperty(props);

    if (this.jarDirIsAuto) {

      // We memoized a user-specific nonce dir for compilation to the data

      // store.  Disregard that setting and create a new nonce dir.

      String localUsername = System.getProperty("user.name", "unknown");

      this.jarOutputDir = getNonceJarDir(tmpDir + "sqoop-" + localUsername

          + "/compile");

    }

    String colListStr = props.getProperty("db.column.list", null);

    if (null != colListStr) {

      this.columns = listToArray(colListStr);

    }

    this.inputDelimiters = getDelimiterProperties(props,

        "codegen.input.delimiters", this.inputDelimiters);

    this.outputDelimiters = getDelimiterProperties(props,

        "codegen.output.delimiters", this.outputDelimiters);

    this.extraArgs = getArgArrayProperty(props, "tool.arguments",

        this.extraArgs);

    this.connectionParams =

        getPropertiesAsNetstedProperties(props, "db.connect.params");

    // Loading user mapping

    this.mapColumnHive =

            getPropertiesAsNetstedProperties(props, "map.column.hive");

    this.mapColumnJava =

            getPropertiesAsNetstedProperties(props, "map.column.java");

    // Delimiters were previously memoized; don't let the tool override

    // them with defaults.

    this.areOutputDelimsManuallySet = true;

    this.areInputDelimsManuallySet = true;

    // If we loaded true verbose flag, we need to apply it

    if (this.verbose) {

      LoggingUtils.setDebugLevel();

    }

  }

  private void loadPasswordProperty(Properties props) {

    passwordFilePath = props.getProperty("db.password.file");

    if (passwordFilePath != null) {

      try {

        password = CredentialsUtil.fetchPasswordFromLoader(passwordFilePath, getConf());

        return; // short-circuit

      } catch (IOException e) {

        throw new RuntimeException("Unable to fetch password from file.", e);

      }

    }

    if (getBooleanProperty(props, "db.require.password", false)) {

      // The user's password was stripped out from the metastore.

      // Require that the user enter it now.

      setPasswordFromConsole();

    } else {

      this.password = props.getProperty("db.password", this.password);

    }

  }

  /**

   * Return a Properties instance that encapsulates all the "sticky"

   * state of this SqoopOptions that should be written to a metastore

   * to restore the job later.

   */

  public Properties writeProperties() {

    Properties props = new Properties();

    try {

      Field [] fields = SqoopOptions.class.getDeclaredFields();

      for (Field f : fields) {

        if (f.isAnnotationPresent(StoredAsProperty.class)) {

          Class typ = f.getType();

          StoredAsProperty storedAs = f.getAnnotation(StoredAsProperty.class);

          String propName = storedAs.value();

          if (typ.equals(int.class)) {

            putProperty(props, propName, Integer.toString(f.getInt(this)));

          } else if (typ.equals(boolean.class)) {

            putProperty(props, propName, Boolean.toString(f.getBoolean(this)));

          } else if (typ.equals(long.class)) {

            putProperty(props, propName, Long.toString(f.getLong(this)));

          } else if (typ.equals(String.class)) {

            putProperty(props, propName, (String) f.get(this));

          } else if (typ.equals(Integer.class)) {

            putProperty(

                props,

                propName,

                f.get(this) == null ? "null" : f.get(this).toString());

          } else if (typ.isEnum()) {

            putProperty(props, propName, f.get(this).toString());

          } else {

            throw new RuntimeException("Could not set property "

                + propName + " for type: " + typ);

          }

        }

      }

    } catch (IllegalAccessException iae) {

      throw new RuntimeException("Illegal access to field in property setter",

          iae);

    }

    writePasswordProperty(props);

    putProperty(props, "db.column.list", arrayToList(this.columns));

    setDelimiterProperties(props, "codegen.input.delimiters",

        this.inputDelimiters);

    setDelimiterProperties(props, "codegen.output.delimiters",

        this.outputDelimiters);

    setArgArrayProperties(props, "tool.arguments", this.extraArgs);

    setPropertiesAsNestedProperties(props,

            "db.connect.params", this.connectionParams);

    setPropertiesAsNestedProperties(props,

            "map.column.hive", this.mapColumnHive);

    setPropertiesAsNestedProperties(props,

            "map.column.java", this.mapColumnJava);

    return props;

  }

  private void writePasswordProperty(Properties props) {

    if (getPasswordFilePath() != null) { // short-circuit

      putProperty(props, "db.password.file", getPasswordFilePath());

      return;

    }

    if (this.getConf().getBoolean(

      METASTORE_PASSWORD_KEY, METASTORE_PASSWORD_DEFAULT)) {

      // If the user specifies, we may store the password in the metastore.

      putProperty(props, "db.password", this.password);

      putProperty(props, "db.require.password", "false");

    } else if (this.password != null) {

      // Otherwise, if the user has set a password, we just record

      // a flag stating that the password will need to be reentered.

      putProperty(props, "db.require.password", "true");

    } else {

      // No password saved or required.

      putProperty(props, "db.require.password", "false");

    }

  }

  @Override

  public Object clone() {

    try {

      SqoopOptions other = (SqoopOptions) super.clone();

      if (null != columns) {

        other.columns = Arrays.copyOf(columns, columns.length);