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

*/

* This class has functions that implement meta data/DDL operations using calls

* to the metastore.

* It has a metastore client instance it uses to communicate with the metastore.

*

* It is a thread local variable, and the instances is accessed using static

* get methods in this class.

*/

  static final private Log LOG = LogFactory.getLog("hive.ql.metadata.Hive");

  private HiveConf conf = null;

  private IMetaStoreClient metaStoreClient;

  private UserGroupInformation owner;

  private static ThreadLocal<Hive> hiveDB = new ThreadLocal<Hive>() {

    @Override

    protected synchronized Hive initialValue() {

      return null;

    }

    @Override

    public synchronized void remove() {

      if (this.get() != null) {

        this.get().close();

      }

      super.remove();

    }

  };

  public static Hive get(Configuration c, Class<?> clazz) throws HiveException {

    return get(c instanceof HiveConf ? (HiveConf)c : new HiveConf(c, clazz));

  }

  /**

   * Gets hive object for the current thread. If one is not initialized then a

   * new one is created If the new configuration is different in metadata conf

   * vars then a new one is created.

   *

   * @param c

   *          new Hive Configuration

   * @return Hive object for current thread

   * @throws HiveException

   *

   */

  public static Hive get(HiveConf c) throws HiveException {

    Hive db = hiveDB.get();

    if (db == null ||

        (db.metaStoreClient != null && !db.metaStoreClient.isCompatibleWith(c))) {

      return get(c, true);

    }

    db.conf = c;

    return db;

  }

  /**

   * get a connection to metastore. see get(HiveConf) function for comments

   *

   * @param c

   *          new conf

   * @param needsRefresh

   *          if true then creates a new one

   * @return The connection to the metastore

   * @throws HiveException

   */

  public static Hive get(HiveConf c, boolean needsRefresh) throws HiveException {

    Hive db = hiveDB.get();

    if (db == null || needsRefresh || !db.isCurrentUserOwner()) {

      if (db != null) {

        LOG.debug("Creating new db. db = " + db + ", needsRefresh = " + needsRefresh +

          ", db.isCurrentUserOwner = " + db.isCurrentUserOwner());

      }

      closeCurrent();

      c.set("fs.scheme.class", "dfs");

      Hive newdb = new Hive(c);

      hiveDB.set(newdb);

      return newdb;

    }

    db.conf = c;

    return db;

  }

  public static Hive get() throws HiveException {

    Hive db = hiveDB.get();

    if (db != null && !db.isCurrentUserOwner()) {

      LOG.debug("Creating new db. db.isCurrentUserOwner = " + db.isCurrentUserOwner());

      db.close();

      db = null;

    }

    if (db == null) {

      SessionState session = SessionState.get();

      db = new Hive(session == null ? new HiveConf(Hive.class) : session.getConf());

      hiveDB.set(db);

    }

    return db;

  }

  public static void set(Hive hive) {

    hiveDB.set(hive);

  }

  public static void closeCurrent() {

    hiveDB.remove();

  }

  /**

   * Hive

   *

   * @param c

   *

   */

  private Hive(HiveConf c) throws HiveException {

    conf = c;

  }

  private boolean isCurrentUserOwner() throws HiveException {

    try {

      return owner == null || owner.equals(UserGroupInformation.getCurrentUser());

    } catch(IOException e) {

      throw new HiveException("Error getting current user: " + e.getMessage(), e);

    }

  }

  /**

   * closes the connection to metastore for the calling thread

   */

  private void close() {

    LOG.debug("Closing current thread's connection to Hive Metastore.");

    if (metaStoreClient != null) {

      metaStoreClient.close();

      metaStoreClient = null;

    }

  }

  /**

   * Create a database

   * @param db

   * @param ifNotExist if true, will ignore AlreadyExistsException exception

   * @throws AlreadyExistsException

   * @throws HiveException

   */

  public void createDatabase(Database db, boolean ifNotExist)

      throws AlreadyExistsException, HiveException {

    try {

      getMSC().createDatabase(db);

    } catch (AlreadyExistsException e) {

      if (!ifNotExist) {

        throw e;

      }

    } catch (Exception e) {

      throw new HiveException(e);

    }

  }

  /**

   * Create a Database. Raise an error if a database with the same name already exists.

   * @param db

   * @throws AlreadyExistsException

   * @throws HiveException

   */

  public void createDatabase(Database db) throws AlreadyExistsException, HiveException {

    createDatabase(db, false);

  }

  /**

   * Drop a database.

   * @param name

   * @throws NoSuchObjectException

   * @throws HiveException

   * @see org.apache.hadoop.hive.metastore.HiveMetaStoreClient#dropDatabase(java.lang.String)

   */

  public void dropDatabase(String name) throws HiveException, NoSuchObjectException {

    dropDatabase(name, true, false, false);

  }

  /**

   * Drop a database

   * @param name

   * @param deleteData

   * @param ignoreUnknownDb if true, will ignore NoSuchObjectException

   * @throws HiveException

   * @throws NoSuchObjectException

   */

  public void dropDatabase(String name, boolean deleteData, boolean ignoreUnknownDb)

      throws HiveException, NoSuchObjectException {

    dropDatabase(name, deleteData, ignoreUnknownDb, false);

  }

  /**

   * Drop a database

   * @param name

   * @param deleteData

   * @param ignoreUnknownDb if true, will ignore NoSuchObjectException

   * @param cascade         if true, delete all tables on the DB if exists. Otherwise, the query

   *                        will fail if table still exists.

   * @throws HiveException

   * @throws NoSuchObjectException

   */

  public void dropDatabase(String name, boolean deleteData, boolean ignoreUnknownDb, boolean cascade)

      throws HiveException, NoSuchObjectException {

    try {

      getMSC().dropDatabase(name, deleteData, ignoreUnknownDb, cascade);

    } catch (NoSuchObjectException e) {

      throw e;

    } catch (Exception e) {

      throw new HiveException(e);

    }

  }

  /**

   * Creates a table metadata and the directory for the table data

   *

   * @param tableName

   *          name of the table

   * @param columns

   *          list of fields of the table

   * @param partCols

   *          partition keys of the table

   * @param fileInputFormat

   *          Class of the input format of the table data file

   * @param fileOutputFormat

   *          Class of the output format of the table data file

   * @throws HiveException

   *           thrown if the args are invalid or if the metadata or the data

   *           directory couldn't be created

   */

  public void createTable(String tableName, List<String> columns,

      List<String> partCols, Class<? extends InputFormat> fileInputFormat,

      Class<?> fileOutputFormat) throws HiveException {

    this.createTable(tableName, columns, partCols, fileInputFormat,

        fileOutputFormat, -1, null);

  }

  /**

   * Creates a table metadata and the directory for the table data

   *

   * @param tableName

   *          name of the table

   * @param columns

   *          list of fields of the table

   * @param partCols

   *          partition keys of the table

   * @param fileInputFormat

   *          Class of the input format of the table data file

   * @param fileOutputFormat

   *          Class of the output format of the table data file

   * @param bucketCount

   *          number of buckets that each partition (or the table itself) should

   *          be divided into

   * @throws HiveException

   *           thrown if the args are invalid or if the metadata or the data

   *           directory couldn't be created

   */

  public void createTable(String tableName, List<String> columns,

      List<String> partCols, Class<? extends InputFormat> fileInputFormat,

      Class<?> fileOutputFormat, int bucketCount, List<String> bucketCols)

      throws HiveException {

    createTable(tableName, columns, partCols, fileInputFormat, fileOutputFormat, bucketCount,

        bucketCols, null);

  }

  /**

   * Create a table metadata and the directory for the table data

   * @param tableName table name

   * @param columns list of fields of the table

   * @param partCols partition keys of the table

   * @param fileInputFormat Class of the input format of the table data file

   * @param fileOutputFormat Class of the output format of the table data file

   * @param bucketCount number of buckets that each partition (or the table itself) should be

   *                    divided into

   * @param bucketCols Bucket columns

   * @param parameters Parameters for the table

   * @throws HiveException

   */

  public void createTable(String tableName, List<String> columns, List<String> partCols,

                          Class<? extends InputFormat> fileInputFormat,

                          Class<?> fileOutputFormat, int bucketCount, List<String> bucketCols,

                          Map<String, String> parameters) throws HiveException {

    if (columns == null) {

      throw new HiveException("columns not specified for table " + tableName);

    }

    Table tbl = newTable(tableName);

    tbl.setInputFormatClass(fileInputFormat.getName());

    tbl.setOutputFormatClass(fileOutputFormat.getName());

    for (String col : columns) {

      FieldSchema field = new FieldSchema(col, STRING_TYPE_NAME, "default");

      tbl.getCols().add(field);

    }

    if (partCols != null) {

      for (String partCol : partCols) {

        FieldSchema part = new FieldSchema();

        part.setName(partCol);

        part.setType(STRING_TYPE_NAME); // default partition key

        tbl.getPartCols().add(part);

      }

    }

    tbl.setSerializationLib(LazySimpleSerDe.class.getName());

    tbl.setNumBuckets(bucketCount);

    tbl.setBucketCols(bucketCols);

    if (parameters != null) {

      tbl.setParamters(parameters);

    }

    createTable(tbl);

  }

  /**

   * Updates the existing table metadata with the new metadata.

   *

   * @param tblName

   *          name of the existing table

   * @param newTbl

   *          new name of the table. could be the old name

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void alterTable(String tblName, Table newTbl)

      throws InvalidOperationException, HiveException {

    String[] names = Utilities.getDbTableName(tblName);

    try {

      // Remove the DDL_TIME so it gets refreshed

      if (newTbl.getParameters() != null) {

        newTbl.getParameters().remove(hive_metastoreConstants.DDL_TIME);

      }

      newTbl.checkValidity();

      getMSC().alter_table(names[0], names[1], newTbl.getTTable());

    } catch (MetaException e) {

      throw new HiveException("Unable to alter table. " + e.getMessage(), e);

    } catch (TException e) {

      throw new HiveException("Unable to alter table. " + e.getMessage(), e);

    }

  }

  public void alterIndex(String baseTableName, String indexName, Index newIdx)

      throws InvalidOperationException, HiveException {

    String[] names = Utilities.getDbTableName(baseTableName);

    alterIndex(names[0], names[1], indexName, newIdx);

  }

  /**

   * Updates the existing index metadata with the new metadata.

   *

   * @param idxName

   *          name of the existing index

   * @param newIdx

   *          new name of the index. could be the old name

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void alterIndex(String dbName, String baseTblName, String idxName, Index newIdx)

      throws InvalidOperationException, HiveException {

    try {

      getMSC().alter_index(dbName, baseTblName, idxName, newIdx);

    } catch (MetaException e) {

      throw new HiveException("Unable to alter index. " + e.getMessage(), e);

    } catch (TException e) {

      throw new HiveException("Unable to alter index. " + e.getMessage(), e);

    }

  }

  /**

   * Updates the existing partition metadata with the new metadata.

   *

   * @param tblName

   *          name of the existing table

   * @param newPart

   *          new partition

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void alterPartition(String tblName, Partition newPart)

      throws InvalidOperationException, HiveException {

    String[] names = Utilities.getDbTableName(tblName);

    alterPartition(names[0], names[1], newPart);

  }

  /**

   * Updates the existing partition metadata with the new metadata.

   *

   * @param dbName

   *          name of the exiting table's database

   * @param tblName

   *          name of the existing table

   * @param newPart

   *          new partition

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void alterPartition(String dbName, String tblName, Partition newPart)

      throws InvalidOperationException, HiveException {

    try {

      // Remove the DDL time so that it gets refreshed

      if (newPart.getParameters() != null) {

        newPart.getParameters().remove(hive_metastoreConstants.DDL_TIME);

      }

      newPart.checkValidity();

      getMSC().alter_partition(dbName, tblName, newPart.getTPartition());

    } catch (MetaException e) {

      throw new HiveException("Unable to alter partition. " + e.getMessage(), e);

    } catch (TException e) {

      throw new HiveException("Unable to alter partition. " + e.getMessage(), e);

    }

  }

  /**

   * Updates the existing table metadata with the new metadata.

   *

   * @param tblName

   *          name of the existing table

   * @param newParts

   *          new partitions

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void alterPartitions(String tblName, List<Partition> newParts)

      throws InvalidOperationException, HiveException {

    String[] names = Utilities.getDbTableName(tblName);

    List<org.apache.hadoop.hive.metastore.api.Partition> newTParts =

      new ArrayList<org.apache.hadoop.hive.metastore.api.Partition>();

    try {

      // Remove the DDL time so that it gets refreshed

      for (Partition tmpPart: newParts) {

        if (tmpPart.getParameters() != null) {

          tmpPart.getParameters().remove(hive_metastoreConstants.DDL_TIME);

        }

        newTParts.add(tmpPart.getTPartition());

      }

      getMSC().alter_partitions(names[0], names[1], newTParts);

    } catch (MetaException e) {

      throw new HiveException("Unable to alter partition. " + e.getMessage(), e);

    } catch (TException e) {

      throw new HiveException("Unable to alter partition. " + e.getMessage(), e);

    }

  }

  /**

   * Rename a old partition to new partition

   *

   * @param tbl

   *          existing table

   * @param oldPartSpec

   *          spec of old partition

   * @param newPart

   *          new partition

   * @throws InvalidOperationException

   *           if the changes in metadata is not acceptable

   * @throws TException

   */

  public void renamePartition(Table tbl, Map<String, String> oldPartSpec, Partition newPart)

      throws HiveException {

    try {

      Map<String, String> newPartSpec = newPart.getSpec();

      if (oldPartSpec.keySet().size() != tbl.getPartCols().size()

          || newPartSpec.keySet().size() != tbl.getPartCols().size()) {

        throw new HiveException("Unable to rename partition to the same name: number of partition cols don't match. ");

      }

      if (!oldPartSpec.keySet().equals(newPartSpec.keySet())){

        throw new HiveException("Unable to rename partition to the same name: old and new partition cols don't match. ");

      }

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

      for (FieldSchema field : tbl.getPartCols()) {

        String val = oldPartSpec.get(field.getName());

        if (val == null || val.length() == 0) {

          throw new HiveException("get partition: Value for key "

              + field.getName() + " is null or empty");

        } else if (val != null){

          pvals.add(val);

        }

      }

      getMSC().renamePartition(tbl.getDbName(), tbl.getTableName(), pvals,

          newPart.getTPartition());

    } catch (InvalidOperationException e){

      throw new HiveException("Unable to rename partition. " + e.getMessage(), e);

    } catch (MetaException e) {

      throw new HiveException("Unable to rename partition. " + e.getMessage(), e);