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

*/

* DDLTask implementation.

*

**/

  private static final long serialVersionUID = 1L;

  private static final Log LOG = LogFactory.getLog("hive.ql.exec.DDLTask");

  transient HiveConf conf;

  private static final int separator = Utilities.tabCode;

  private static final int terminator = Utilities.newLineCode;

  // These are suffixes attached to intermediate directory names used in the

  // archiving / un-archiving process.

  private static String INTERMEDIATE_ARCHIVED_DIR_SUFFIX;

  private static String INTERMEDIATE_ORIGINAL_DIR_SUFFIX;

  private static String INTERMEDIATE_EXTRACTED_DIR_SUFFIX;

  public DDLTask() {

    super();

  }

  @Override

  public void initialize(HiveConf conf, QueryPlan queryPlan, DriverContext ctx) {

    super.initialize(conf, queryPlan, ctx);

    this.conf = conf;

    INTERMEDIATE_ARCHIVED_DIR_SUFFIX =

      HiveConf.getVar(conf, ConfVars.METASTORE_INT_ARCHIVED);

    INTERMEDIATE_ORIGINAL_DIR_SUFFIX =

      HiveConf.getVar(conf, ConfVars.METASTORE_INT_ORIGINAL);

    INTERMEDIATE_EXTRACTED_DIR_SUFFIX =

      HiveConf.getVar(conf, ConfVars.METASTORE_INT_EXTRACTED);

  }

  @Override

  public int execute(DriverContext driverContext) {

    // Create the db

    Hive db;

    try {

      db = Hive.get(conf);

      CreateDatabaseDesc createDatabaseDesc = work.getCreateDatabaseDesc();

      if (null != createDatabaseDesc) {

        return createDatabase(db, createDatabaseDesc);

      }

      DropDatabaseDesc dropDatabaseDesc = work.getDropDatabaseDesc();

      if (dropDatabaseDesc != null) {

        return dropDatabase(db, dropDatabaseDesc);

      }

      SwitchDatabaseDesc switchDatabaseDesc = work.getSwitchDatabaseDesc();

      if (switchDatabaseDesc != null) {

        return switchDatabase(db, switchDatabaseDesc);

      }

     

      CreateTableDesc crtTbl = work.getCreateTblDesc();

      if (crtTbl != null) {

        return createTable(db, crtTbl);

      }

      CreateTableLikeDesc crtTblLike = work.getCreateTblLikeDesc();

      if (crtTblLike != null) {

        return createTableLike(db, crtTblLike);

      }

      DropTableDesc dropTbl = work.getDropTblDesc();

      if (dropTbl != null) {

        return dropTable(db, dropTbl);

      }

      AlterTableDesc alterTbl = work.getAlterTblDesc();

      if (alterTbl != null) {

        return alterTable(db, alterTbl);

      }

      CreateViewDesc crtView = work.getCreateViewDesc();

      if (crtView != null) {

        return createView(db, crtView);

      }

      AddPartitionDesc addPartitionDesc = work.getAddPartitionDesc();

      if (addPartitionDesc != null) {

        return addPartition(db, addPartitionDesc);

      }

      AlterTableSimpleDesc simpleDesc = work.getAlterTblSimpleDesc();

      if(simpleDesc != null) {

        if (simpleDesc.getType() == AlterTableTypes.TOUCH) {

          return touch(db, simpleDesc);

        } else if (simpleDesc.getType() == AlterTableTypes.ARCHIVE) {

          return archive(db, simpleDesc, driverContext);

        } else if (simpleDesc.getType() == AlterTableTypes.UNARCHIVE) {

          return unarchive(db, simpleDesc);

        }

      }

      MsckDesc msckDesc = work.getMsckDesc();

      if (msckDesc != null) {

        return msck(db, msckDesc);

      }

      DescTableDesc descTbl = work.getDescTblDesc();

      if (descTbl != null) {

        return describeTable(db, descTbl);

      }

      DescFunctionDesc descFunc = work.getDescFunctionDesc();

      if (descFunc != null) {

        return describeFunction(descFunc);

      }

      ShowDatabasesDesc showDatabases = work.getShowDatabasesDesc();

      if (showDatabases != null) {

        return showDatabases(db, showDatabases);

      }

      ShowTablesDesc showTbls = work.getShowTblsDesc();

      if (showTbls != null) {

        return showTables(db, showTbls);

      }

      ShowTableStatusDesc showTblStatus = work.getShowTblStatusDesc();

      if (showTblStatus != null) {

        return showTableStatus(db, showTblStatus);

      }

      ShowFunctionsDesc showFuncs = work.getShowFuncsDesc();

      if (showFuncs != null) {

        return showFunctions(showFuncs);

      }

      ShowPartitionsDesc showParts = work.getShowPartsDesc();

      if (showParts != null) {

        return showPartitions(db, showParts);

      }

    } catch (InvalidTableException e) {

      console.printError("Table " + e.getTableName() + " does not exist");

      LOG.debug(stringifyException(e));

      return 1;

    } catch (HiveException e) {

      console.printError("FAILED: Error in metadata: " + e.getMessage(), "\n"

          + stringifyException(e));

      LOG.debug(stringifyException(e));

      return 1;

    } catch (Exception e) {

      console.printError("Failed with exception " + e.getMessage(), "\n"

          + stringifyException(e));

      return (1);

    }

    assert false;

    return 0;

  }

  /**

   * Add a partition to a table.

   *

   * @param db

   *          Database to add the partition to.

   * @param addPartitionDesc

   *          Add this partition.

   * @return Returns 0 when execution succeeds and above 0 if it fails.

   * @throws HiveException

   */

  private int addPartition(Hive db, AddPartitionDesc addPartitionDesc) throws HiveException {

    Table tbl = db.getTable(addPartitionDesc.getDbName(), addPartitionDesc

        .getTableName());

    validateAlterTableType(tbl, AlterTableDesc.AlterTableTypes.ADDPARTITION);

    // If the add partition was created with IF NOT EXISTS, then we should

    // not throw an error if the specified part does exist.

    Partition checkPart = db.getPartition(tbl, addPartitionDesc.getPartSpec(), false);

    if (checkPart != null && addPartitionDesc.getIfNotExists()) {

      return 0;

    }

    if (addPartitionDesc.getLocation() == null) {

      db.createPartition(tbl, addPartitionDesc.getPartSpec());

    } else {

      // set partition path relative to table

      db.createPartition(tbl, addPartitionDesc.getPartSpec(), new Path(tbl

          .getPath(), addPartitionDesc.getLocation()));

    }

    Partition part = db

        .getPartition(tbl, addPartitionDesc.getPartSpec(), false);

    work.getOutputs().add(new WriteEntity(part));

    return 0;

  }

  /**

   * Rewrite the partition's metadata and force the pre/post execute hooks to

   * be fired.

   *

   * @param db

   * @param touchDesc

   * @return

   * @throws HiveException

   */

  private int touch(Hive db, AlterTableSimpleDesc touchDesc)

      throws HiveException {

    String dbName = touchDesc.getDbName();

    String tblName = touchDesc.getTableName();

    Table tbl = db.getTable(dbName, tblName);

    validateAlterTableType(tbl, AlterTableDesc.AlterTableTypes.TOUCH);

    if (touchDesc.getPartSpec() == null) {

      try {

        db.alterTable(tblName, tbl);

      } catch (InvalidOperationException e) {

        throw new HiveException("Uable to update table");

      }

      work.getInputs().add(new ReadEntity(tbl));

      work.getOutputs().add(new WriteEntity(tbl));

    } else {

      Partition part = db.getPartition(tbl, touchDesc.getPartSpec(), false);

      if (part == null) {

        throw new HiveException("Specified partition does not exist");

      }

      try {

        db.alterPartition(tblName, part);

      } catch (InvalidOperationException e) {

        throw new HiveException(e);

      }

      work.getInputs().add(new ReadEntity(part));

      work.getOutputs().add(new WriteEntity(part));

    }

    return 0;

  }

  /**

   * Determines whether a partition has been archived

   *

   * @param p

   * @return

   */

  private boolean isArchived(Partition p) {

    Map<String, String> params = p.getParameters();

    if ("true".equalsIgnoreCase(params.get(

        org.apache.hadoop.hive.metastore.api.Constants.IS_ARCHIVED))) {

      return true;

    } else {

      return false;

    }

  }

  private void setIsArchived(Partition p, boolean state) {

    Map<String, String> params = p.getParameters();

    if (state) {

      params.put(org.apache.hadoop.hive.metastore.api.Constants.IS_ARCHIVED,

          "true");

    } else {

      params.remove(org.apache.hadoop.hive.metastore.api.Constants.IS_ARCHIVED);

    }

  }

  private String getOriginalLocation(Partition p) {

    Map<String, String> params = p.getParameters();

    return params.get(

        org.apache.hadoop.hive.metastore.api.Constants.ORIGINAL_LOCATION);

  }

  private void setOriginalLocation(Partition p, String loc) {

    Map<String, String> params = p.getParameters();

    if (loc == null) {

      params.remove(org.apache.hadoop.hive.metastore.api.Constants.ORIGINAL_LOCATION);

    } else {

      params.put(org.apache.hadoop.hive.metastore.api.Constants.ORIGINAL_LOCATION, loc);

    }

  }

  // Returns only the path component of the URI

  private String getArchiveDirOnly(Path parentDir, String archiveName) {

    URI parentUri = parentDir.toUri();

    Path harDir = new Path(parentUri.getPath(), archiveName);

    return harDir.toString();

  }

  /**

   * Sets the appropriate attributes in the supplied Partition object to mark

   * it as archived. Note that the metastore is not touched - a separate

   * call to alter_partition is needed.

   *

   * @param p - the partition object to modify

   * @param parentDir - the parent directory of the archive, which is the

   * original directory that the partition's files resided in

   * @param dirInArchive - the directory within the archive file that contains

   * the partitions files

   * @param archiveName - the name of the archive

   * @throws URISyntaxException

   */

  private void setArchived(Partition p, Path parentDir, String dirInArchive, String archiveName)

      throws URISyntaxException {

    assert(isArchived(p) == false);

    Map<String, String> params = p.getParameters();

    URI parentUri = parentDir.toUri();

    String parentHost = parentUri.getHost();

    String harHost = null;

    if (parentHost == null) {

     harHost = "";

    } else {

      harHost = parentUri.getScheme() + "-" + parentHost;

    }

    // harUri is used to access the partition's files, which are in the archive

    // The format of the RI is something like:

    // har://underlyingfsscheme-host:port/archivepath

    URI harUri = null;

    if (dirInArchive.length() == 0) {

      harUri = new URI("har", parentUri.getUserInfo(), harHost, parentUri.getPort(),

          getArchiveDirOnly(parentDir, archiveName),

          parentUri.getQuery(), parentUri.getFragment());

    } else {

      harUri = new URI("har", parentUri.getUserInfo(), harHost, parentUri.getPort(),

          new Path(getArchiveDirOnly(parentDir, archiveName), dirInArchive).toUri().getPath(),

          parentUri.getQuery(), parentUri.getFragment());

    }

    setIsArchived(p, true);

    setOriginalLocation(p, parentDir.toString());

    p.setLocation(harUri.toString());

  }

  /**

   * Sets the appropriate attributes in the supplied Partition object to mark

   * it as not archived. Note that the metastore is not touched - a separate

   * call to alter_partition is needed.

   *

   * @param p - the partition to modify

   */

  private void setUnArchived(Partition p) {

    assert(isArchived(p) == true);

    String parentDir = getOriginalLocation(p);

    setIsArchived(p, false);

    setOriginalLocation(p, null);

    assert(parentDir != null);

    p.setLocation(parentDir);

  }

  private boolean pathExists(FileSystem fs, Path p) throws HiveException {

    try {

      return fs.exists(p);

    } catch (IOException e) {

      throw new HiveException(e);

    }

  }

  private void moveDir(FileSystem fs, Path from, Path to) throws HiveException {

    try {

      if (!fs.rename(from, to)) {

        throw new HiveException("Moving " + from + " to " + to + " failed!");

      }

    } catch (IOException e) {

      throw new HiveException(e);

    }

  }

  private void deleteDir(Path dir) throws HiveException {

    try {

      Warehouse wh = new Warehouse(conf);

      wh.deleteDir(dir, true);

    } catch (MetaException e) {

      throw new HiveException(e);

    }

  }

  private int archive(Hive db, AlterTableSimpleDesc simpleDesc, DriverContext driverContext)

      throws HiveException {

    String dbName = simpleDesc.getDbName();

    String tblName = simpleDesc.getTableName();

    Table tbl = db.getTable(dbName, tblName);

    validateAlterTableType(tbl, AlterTableDesc.AlterTableTypes.ARCHIVE);

    Map<String, String> partSpec = simpleDesc.getPartSpec();

    Partition p = db.getPartition(tbl, partSpec, false);

    if (tbl.getTableType() != TableType.MANAGED_TABLE) {

      throw new HiveException("ARCHIVE can only be performed on managed tables");

    }

    if (p == null) {

      throw new HiveException("Specified partition does not exist");

    }

    if (isArchived(p)) {

      // If there were a failure right after the metadata was updated in an

      // archiving operation, it's possible that the original, unarchived files

      // weren't deleted.

      Path originalDir = new Path(getOriginalLocation(p));

      Path leftOverIntermediateOriginal = new Path(originalDir.getParent(),

          originalDir.getName() + INTERMEDIATE_ORIGINAL_DIR_SUFFIX);

      try {

        if (pathExists(leftOverIntermediateOriginal.getFileSystem(conf),

            leftOverIntermediateOriginal)) {

          console.printInfo("Deleting " + leftOverIntermediateOriginal +

              " left over from a previous archiving operation");

          deleteDir(leftOverIntermediateOriginal);

        }

      } catch (IOException e) {

        throw new HiveException(e);

      }

      throw new HiveException("Specified partition is already archived");

    }

    Path originalDir = p.getPartitionPath();

    Path intermediateArchivedDir = new Path(originalDir.getParent(),

        originalDir.getName() + INTERMEDIATE_ARCHIVED_DIR_SUFFIX);

    Path intermediateOriginalDir = new Path(originalDir.getParent(),

        originalDir.getName() + INTERMEDIATE_ORIGINAL_DIR_SUFFIX);

    String archiveName = "data.har";

    FileSystem fs = null;

    try {

      fs = originalDir.getFileSystem(conf);

    } catch (IOException e) {

      throw new HiveException(e);

    }

    // The following steps seem roundabout, but they are meant to aid in

    // recovery if a failure occurs and to keep a consistent state in the FS

    // Steps:

    // 1. Create the archive in a temporary folder

    // 2. Move the archive dir to an intermediate dir that is in at the same

    //    dir as the original partition dir. Call the new dir

    //    intermediate-archive.

    // 3. Rename the original partition dir to an intermediate dir. Call the

    //    renamed dir intermediate-original

    // 4. Rename intermediate-archive to the original partition dir

    // 5. Change the metadata

    // 6. Delete the original partition files in intermediate-original

    // The original partition files are deleted after the metadata change

    // because the presence of those files are used to indicate whether

    // the original partition directory contains archived or unarchived files.

    // Create an archived version of the partition in a directory ending in

    // ARCHIVE_INTERMEDIATE_DIR_SUFFIX that's the same level as the partition,

    // if it does not already exist. If it does exist, we assume the dir is good

    // to use as the move operation that created it is atomic.

    if (!pathExists(fs, intermediateArchivedDir) &&

        !pathExists(fs, intermediateOriginalDir)) {

      // First create the archive in a tmp dir so that if the job fails, the

      // bad files don't pollute the filesystem

      Path tmpDir = new Path(driverContext.getCtx().getMRScratchDir(), "partlevel");

      console.printInfo("Creating " + archiveName + " for " + originalDir.toString());

      console.printInfo("in " + tmpDir);

      console.printInfo("Please wait... (this may take a while)");

      // Create the Hadoop archive

      HadoopShims shim = ShimLoader.getHadoopShims();

      int ret=0;

      try {

        ret = shim.createHadoopArchive(conf, originalDir, tmpDir, archiveName);

      } catch (Exception e) {

        throw new HiveException(e);

      }

      if (ret != 0) {

        throw new HiveException("Error while creating HAR");

      }

      // Move from the tmp dir to an intermediate directory, in the same level as

      // the partition directory. e.g. .../hr=12-intermediate-archived

      try {

        console.printInfo("Moving " + tmpDir + " to " + intermediateArchivedDir);

        if (pathExists(fs, intermediateArchivedDir)) {

          throw new HiveException("The intermediate archive directory already exists.");

        }

        fs.rename(tmpDir, intermediateArchivedDir);

      } catch (IOException e) {

        throw new HiveException("Error while moving tmp directory");

      }

    } else {

      if (pathExists(fs, intermediateArchivedDir)) {

        console.printInfo("Intermediate archive directory " + intermediateArchivedDir +

        " already exists. Assuming it contains an archived version of the partition");

      }

    }

    // If we get to here, we know that we've archived the partition files, but

    // they may be in the original partition location, or in the intermediate

    // original dir.

    // Move the original parent directory to the intermediate original directory

    // if the move hasn't been made already

    if (!pathExists(fs, intermediateOriginalDir)) {

      console.printInfo("Moving " + originalDir + " to " +

          intermediateOriginalDir);

      moveDir(fs, originalDir, intermediateOriginalDir);

    } else {

      console.printInfo(intermediateOriginalDir + " already exists. " +

          "Assuming it contains the original files in the partition");

    }

    // If there's a failure from here to when the metadata is updated,

    // there will be no data in the partition, or an error while trying to read

    // the partition (if the archive files have been moved to the original

    // partition directory.) But re-running the archive command will allow

    // recovery

    // Move the intermediate archived directory to the original parent directory

    if (!pathExists(fs, originalDir)) {

      console.printInfo("Moving " + intermediateArchivedDir + " to " +

          originalDir);

      moveDir(fs, intermediateArchivedDir, originalDir);

    } else {

      console.printInfo(originalDir + " already exists. " +

          "Assuming it contains the archived version of the partition");

    }

    // Record this change in the metastore

    try {

      boolean parentSettable =

        conf.getBoolVar(HiveConf.ConfVars.HIVEHARPARENTDIRSETTABLE);

      // dirInArchive is the directory within the archive that has all the files

      // for this partition. With older versions of Hadoop, archiving a

      // a directory would produce the same directory structure

      // in the archive. So if you created myArchive.har of /tmp/myDir, the

      // files in /tmp/myDir would be located under myArchive.har/tmp/myDir/*

      // In this case, dirInArchive should be tmp/myDir

      // With newer versions of Hadoop, the parent directory could be specified.

      // Assuming the parent directory was set to /tmp/myDir when creating the

      // archive, the files can be found under myArchive.har/*

      // In this case, dirInArchive should be empty

      String dirInArchive = "";

      if (!parentSettable) {

        dirInArchive = originalDir.toUri().getPath();

        if(dirInArchive.length() > 1 && dirInArchive.charAt(0)=='/') {

          dirInArchive = dirInArchive.substring(1);

        }

      }

      setArchived(p, originalDir, dirInArchive, archiveName);

      db.alterPartition(tblName, p);

    } catch (Exception e) {

      throw new HiveException("Unable to change the partition info for HAR", e);

    }

    // If a failure occurs here, the directory containing the original files

    // will not be deleted. The user will run ARCHIVE again to clear this up

    deleteDir(intermediateOriginalDir);

    return 0;

  }

  private int unarchive(Hive db, AlterTableSimpleDesc simpleDesc)

      throws HiveException {

    String dbName = simpleDesc.getDbName();

    String tblName = simpleDesc.getTableName();

    Table tbl = db.getTable(dbName, tblName);

    validateAlterTableType(tbl, AlterTableDesc.AlterTableTypes.UNARCHIVE);

    // Means user specified a table, not a partition

    if (simpleDesc.getPartSpec() == null) {

      throw new HiveException("ARCHIVE is for partitions only");

    }

    Map<String, String> partSpec = simpleDesc.getPartSpec();

    Partition p = db.getPartition(tbl, partSpec, false);

    if (tbl.getTableType() != TableType.MANAGED_TABLE) {

      throw new HiveException("UNARCHIVE can only be performed on managed tables");

    }

    if (p == null) {

      throw new HiveException("Specified partition does not exist");

    }

    if (!isArchived(p)) {

      Path location = new Path(p.getLocation());

      Path leftOverArchiveDir = new Path(location.getParent(),

          location.getName() + INTERMEDIATE_ARCHIVED_DIR_SUFFIX);

      try {

        if (pathExists(location.getFileSystem(conf), leftOverArchiveDir)) {

          console.printInfo("Deleting " + leftOverArchiveDir + " left over " +

          "from a previous unarchiving operation");

          deleteDir(leftOverArchiveDir);

        }

      } catch (IOException e) {

        throw new HiveException(e);

      }

      throw new HiveException("Specified partition is not archived");

    }

    Path originalLocation = new Path(getOriginalLocation(p));

    Path sourceDir = new Path(p.getLocation());

    Path intermediateArchiveDir = new Path(originalLocation.getParent(),

        originalLocation.getName() + INTERMEDIATE_ARCHIVED_DIR_SUFFIX);

    Path intermediateExtractedDir = new Path(originalLocation.getParent(),

        originalLocation.getName() + INTERMEDIATE_EXTRACTED_DIR_SUFFIX);

    Path tmpDir = new Path(driverContext.getCtx().getMRScratchDir());

    FileSystem fs = null;

    try {

      fs = tmpDir.getFileSystem(conf);

      // Verify that there are no files in the tmp dir, because if there are, it

      // would be copied to the partition

      FileStatus [] filesInTmpDir = fs.listStatus(tmpDir);

      if (filesInTmpDir.length != 0) {

        for (FileStatus file : filesInTmpDir) {

          console.printInfo(file.getPath().toString());

        }

        throw new HiveException("Temporary directory " + tmpDir + " is not empty");

      }

    } catch (IOException e) {

      throw new HiveException(e);

    }

    // Some sanity checks

    if (originalLocation == null) {

      throw new HiveException("Missing archive data in the partition");

    }

    if (!"har".equals(sourceDir.toUri().getScheme())) {

      throw new HiveException("Location should refer to a HAR");

    }

    // Clarification of terms:

    // - The originalLocation directory represents the original directory of the

    //   partition's files. They now contain an archived version of those files

    //   eg. hdfs:/warehouse/myTable/ds=1/

    // - The source directory is the directory containing all the files that

    //   should be in the partition. e.g. har:/warehouse/myTable/ds=1/myTable.har/

    //   Note the har:/ scheme

    // Steps:

    // 1. Extract the archive in a temporary folder

    // 2. Move the archive dir to an intermediate dir that is in at the same

    //    dir as originalLocation. Call the new dir intermediate-extracted.

    // 3. Rename the original partition dir to an intermediate dir. Call the

    //    renamed dir intermediate-archive

    // 4. Rename intermediate-extracted to the original partition dir

    // 5. Change the metadata

    // 6. Delete the archived partition files in intermediate-archive

    if (!pathExists(fs, intermediateExtractedDir) &&

        !pathExists(fs, intermediateArchiveDir)) {

      try {

        // Copy the files out of the archive into the temporary directory

        String copySource = (new Path(sourceDir, "*")).toString();

        String copyDest = tmpDir.toString();

        List<String> args = new ArrayList<String>();

        args.add("-cp");

        args.add(copySource);

        args.add(copyDest);

        console.printInfo("Copying " + copySource + " to " + copyDest);

        FsShell fss = new FsShell(conf);

        int ret = 0;

        try {

          ret = ToolRunner.run(fss, args.toArray(new String[0]));

        } catch (Exception e) {

          throw new HiveException(e);

        }

        if (ret != 0) {

          throw new HiveException("Error while copying files from archive");

        }

        console.printInfo("Moving " + tmpDir + " to " + intermediateExtractedDir);

        if (fs.exists(intermediateExtractedDir)) {

          throw new HiveException("Invalid state: the intermediate extracted " +

              "directory already exists.");

        }

        fs.rename(tmpDir, intermediateExtractedDir);

      } catch (Exception e) {

        throw new HiveException(e);

      }

    }

    // At this point, we know that the extracted files are in the intermediate

    // extracted dir, or in the the original directory.

    if (!pathExists(fs, intermediateArchiveDir)) {

      try {

        console.printInfo("Moving " + originalLocation + " to " + intermediateArchiveDir);

        fs.rename(originalLocation, intermediateArchiveDir);

      } catch (IOException e) {

        throw new HiveException(e);

      }

    } else {

      console.printInfo(intermediateArchiveDir + " already exists. " +

      "Assuming it contains the archived version of the partition");

    }

    // If there is a failure from here to until when the metadata is changed,

    // the partition will be empty or throw errors on read.

    // If the original location exists here, then it must be the extracted files

    // because in the previous step, we moved the previous original location

    // (containing the archived version of the files) to intermediateArchiveDir

    if (!pathExists(fs, originalLocation)) {

      try {

        console.printInfo("Moving " + intermediateExtractedDir + " to " + originalLocation);

        fs.rename(intermediateExtractedDir, originalLocation);

      } catch (IOException e) {

        throw new HiveException(e);

      }

    } else {

      console.printInfo(originalLocation + " already exists. " +

      "Assuming it contains the extracted files in the partition");

    }

    setUnArchived(p);

    try {

      db.alterPartition(tblName, p);

    } catch (InvalidOperationException e) {

      throw new HiveException(e);

    }

    // If a failure happens here, the intermediate archive files won't be

    // deleted. The user will need to call unarchive again to clear those up.

    deleteDir(intermediateArchiveDir);

    return 0;

  }

  private void validateAlterTableType(

    Table tbl, AlterTableDesc.AlterTableTypes alterType)  throws HiveException {

    if (tbl.isView()) {

      switch (alterType) {

      case ADDPROPS:

        // allow this form

        break;

      default:

        throw new HiveException(

          "Cannot use this form of ALTER TABLE on a view");

      }

    }

    if (tbl.isNonNative()) {

      throw new HiveException("Cannot use ALTER TABLE on a non-native table");

    }

  }

  /**

   * MetastoreCheck, see if the data in the metastore matches what is on the

   * dfs. Current version checks for tables and partitions that are either

   * missing on disk on in the metastore.

   *

   * @param db

   *          The database in question.

   * @param msckDesc

   *          Information about the tables and partitions we want to check for.

   * @return Returns 0 when execution succeeds and above 0 if it fails.

   */

  private int msck(Hive db, MsckDesc msckDesc) {

    CheckResult result = new CheckResult();

    List<String> repairOutput = new ArrayList<String>();

    try {

      HiveMetaStoreChecker checker = new HiveMetaStoreChecker(db);

      checker.checkMetastore(db.getCurrentDatabase(), msckDesc

          .getTableName(), msckDesc.getPartSpecs(), result);

      if (msckDesc.isRepairPartitions()) {

        Table table = db.getTable(msckDesc.getTableName());

        for (CheckResult.PartitionResult part : result.getPartitionsNotInMs()) {

          try {

            db.createPartition(table, Warehouse.makeSpecFromName(part

                .getPartitionName()));

            repairOutput.add("Repair: Added partition to metastore "

                + msckDesc.getTableName() + ':' + part.getPartitionName());

          } catch (Exception e) {

            LOG.warn("Repair error, could not add partition to metastore: ", e);

          }

        }

      }

    } catch (HiveException e) {

      LOG.warn("Failed to run metacheck: ", e);

      return 1;

    } catch (IOException e) {

      LOG.warn("Failed to run metacheck: ", e);

      return 1;

    } finally {

      BufferedWriter resultOut = null;

      try {

        Path resFile = new Path(msckDesc.getResFile());

        FileSystem fs = resFile.getFileSystem(conf);

        resultOut = new BufferedWriter(new OutputStreamWriter(fs

            .create(resFile)));

        boolean firstWritten = false;

        firstWritten |= writeMsckResult(result.getTablesNotInMs(),

            "Tables not in metastore:", resultOut, firstWritten);

        firstWritten |= writeMsckResult(result.getTablesNotOnFs(),

            "Tables missing on filesystem:", resultOut, firstWritten);

        firstWritten |= writeMsckResult(result.getPartitionsNotInMs(),

            "Partitions not in metastore:", resultOut, firstWritten);

        firstWritten |= writeMsckResult(result.getPartitionsNotOnFs(),

            "Partitions missing from filesystem:", resultOut, firstWritten);

        for (String rout : repairOutput) {

          if (firstWritten) {

            resultOut.write(terminator);

          } else {

            firstWritten = true;

          }

          resultOut.write(rout);

        }

      } catch (IOException e) {

        LOG.warn("Failed to save metacheck output: ", e);