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

*/

* Hive Metastore Client.

*/

  ThriftHiveMetastore.Iface client = null;

  private TTransport transport = null;

  private boolean isConnected = false;

  private URI metastoreUris[];

  private final HiveMetaHookLoader hookLoader;

  private final HiveConf conf;

  private String tokenStrForm;

  private final boolean localMetaStore;

  // for thrift connects

  private int retries = 5;

  private int retryDelaySeconds = 0;

  static final private Log LOG = LogFactory.getLog("hive.metastore");

  public HiveMetaStoreClient(HiveConf conf)

    throws MetaException {

    this(conf, null);

  }

  public HiveMetaStoreClient(HiveConf conf, HiveMetaHookLoader hookLoader)

    throws MetaException {

    this.hookLoader = hookLoader;

    if (conf == null) {

      conf = new HiveConf(HiveMetaStoreClient.class);

    }

    this.conf = conf;

    String msUri = conf.getVar(HiveConf.ConfVars.METASTOREURIS);

    localMetaStore = (msUri == null) ? true : msUri.trim().isEmpty();

    if (localMetaStore) {

      // instantiate the metastore server handler directly instead of connecting

      // through the network

      client = HiveMetaStore.newHMSHandler("hive client", conf);

      isConnected = true;

      return;

    }

    // get the number retries

    retries = HiveConf.getIntVar(conf, HiveConf.ConfVars.METASTORETHRIFTCONNECTIONRETRIES);

    retryDelaySeconds = conf.getIntVar(ConfVars.METASTORE_CLIENT_CONNECT_RETRY_DELAY);

    // user wants file store based configuration

    if (conf.getVar(HiveConf.ConfVars.METASTOREURIS) != null) {

      String metastoreUrisString[] = conf.getVar(

          HiveConf.ConfVars.METASTOREURIS).split(",");

      metastoreUris = new URI[metastoreUrisString.length];

      try {

        int i = 0;

        for (String s : metastoreUrisString) {

          URI tmpUri = new URI(s);

          if (tmpUri.getScheme() == null) {

            throw new IllegalArgumentException("URI: " + s

                + " does not have a scheme");

          }

          metastoreUris[i++] = tmpUri;

        }

      } catch (IllegalArgumentException e) {

        throw (e);

      } catch (Exception e) {

        MetaStoreUtils.logAndThrowMetaException(e);

      }

    } else if (conf.getVar(HiveConf.ConfVars.METASTOREDIRECTORY) != null) {

      metastoreUris = new URI[1];

      try {

        metastoreUris[0] = new URI(conf

            .getVar(HiveConf.ConfVars.METASTOREDIRECTORY));

      } catch (URISyntaxException e) {

        MetaStoreUtils.logAndThrowMetaException(e);

      }

    } else {

      LOG.error("NOT getting uris from conf");

      throw new MetaException("MetaStoreURIs not found in conf file");

    }

    // finally open the store

    open();

  }

  /**

   * Swaps the first element of the metastoreUris array with a random element from the

   * remainder of the array.

   */

  private void promoteRandomMetaStoreURI() {

    if (metastoreUris.length <= 1) {

      return;

    }

    Random rng = new Random();

    int index = rng.nextInt(metastoreUris.length - 1) + 1;

    URI tmp = metastoreUris[0];

    metastoreUris[0] = metastoreUris[index];

    metastoreUris[index] = tmp;

  }

  @Override

  public void reconnect() throws MetaException {

    if (localMetaStore) {

      // For direct DB connections we don't yet support reestablishing connections.

      throw new MetaException("For direct MetaStore DB connections, we don't support retries" +

          " at the client level.");

    } else {

      // Swap the first element of the metastoreUris[] with a random element from the rest

      // of the array. Rationale being that this method will generally be called when the default

      // connection has died and the default connection is likely to be the first array element.

      promoteRandomMetaStoreURI();

      open();

    }

  }

  /**

   * @param dbname

   * @param tbl_name

   * @param new_tbl

   * @throws InvalidOperationException

   * @throws MetaException

   * @throws TException

   * @see

   *   org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#alter_table(

   *   java.lang.String, java.lang.String,

   *   org.apache.hadoop.hive.metastore.api.Table)

   */

  @Override

  public void alter_table(String dbname, String tbl_name, Table new_tbl)

      throws InvalidOperationException, MetaException, TException {

    alter_table(dbname, tbl_name, new_tbl, null);

  }

  public void alter_table(String dbname, String tbl_name, Table new_tbl,

      EnvironmentContext envContext) throws InvalidOperationException, MetaException, TException {

    client.alter_table_with_environment_context(dbname, tbl_name, new_tbl, envContext);

  }

  /**

   * @param dbname

   * @param name

   * @param part_vals

   * @param newPart

   * @throws InvalidOperationException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#rename_partition(

   *      java.lang.String, java.lang.String, java.util.List, org.apache.hadoop.hive.metastore.api.Partition)

   */

  @Override

  public void renamePartition(final String dbname, final String name, final List<String> part_vals, final Partition newPart)

      throws InvalidOperationException, MetaException, TException {

    client.rename_partition(dbname, name, part_vals, newPart);

  }

  private void open() throws MetaException {

    isConnected = false;

    TTransportException tte = null;

    HadoopShims shim = ShimLoader.getHadoopShims();

    boolean useSasl = conf.getBoolVar(ConfVars.METASTORE_USE_THRIFT_SASL);

    boolean useFramedTransport = conf.getBoolVar(ConfVars.METASTORE_USE_THRIFT_FRAMED_TRANSPORT);

    int clientSocketTimeout = conf.getIntVar(ConfVars.METASTORE_CLIENT_SOCKET_TIMEOUT);

    for (int attempt = 0; !isConnected && attempt < retries; ++attempt) {

      for (URI store : metastoreUris) {

        LOG.info("Trying to connect to metastore with URI " + store);

        try {

          transport = new TSocket(store.getHost(), store.getPort(), 1000 * clientSocketTimeout);

          if (useSasl) {

            // Wrap thrift connection with SASL for secure connection.

            try {

              HadoopThriftAuthBridge.Client authBridge =

                ShimLoader.getHadoopThriftAuthBridge().createClient();

              // check if we should use delegation tokens to authenticate

              // the call below gets hold of the tokens if they are set up by hadoop

              // this should happen on the map/reduce tasks if the client added the

              // tokens into hadoop's credential store in the front end during job

              // submission.

              String tokenSig = conf.get("hive.metastore.token.signature");

              // tokenSig could be null

              tokenStrForm = shim.getTokenStrForm(tokenSig);

              if(tokenStrForm != null) {

                // authenticate using delegation tokens via the "DIGEST" mechanism

                transport = authBridge.createClientTransport(null, store.getHost(),

                    "DIGEST", tokenStrForm, transport,

                        MetaStoreUtils.getMetaStoreSaslProperties(conf));

              } else {

                String principalConfig =

                    conf.getVar(HiveConf.ConfVars.METASTORE_KERBEROS_PRINCIPAL);

                transport = authBridge.createClientTransport(

                    principalConfig, store.getHost(), "KERBEROS", null,

                    transport, MetaStoreUtils.getMetaStoreSaslProperties(conf));

              }

            } catch (IOException ioe) {

              LOG.error("Couldn't create client transport", ioe);

              throw new MetaException(ioe.toString());

            }

          } else if (useFramedTransport) {

            transport = new TFramedTransport(transport);

          }

          client = new ThriftHiveMetastore.Client(new TBinaryProtocol(transport));

          try {

            transport.open();

            isConnected = true;

          } catch (TTransportException e) {

            tte = e;

            if (LOG.isDebugEnabled()) {

              LOG.warn("Failed to connect to the MetaStore Server...", e);

            } else {

              // Don't print full exception trace if DEBUG is not on.

              LOG.warn("Failed to connect to the MetaStore Server...");

            }

          }

          if (isConnected && !useSasl && conf.getBoolVar(ConfVars.METASTORE_EXECUTE_SET_UGI)){

            // Call set_ugi, only in unsecure mode.

            try {

              UserGroupInformation ugi = shim.getUGIForConf(conf);

              client.set_ugi(ugi.getUserName(), Arrays.asList(ugi.getGroupNames()));

            } catch (LoginException e) {

              LOG.warn("Failed to do login. set_ugi() is not successful, " +

                       "Continuing without it.", e);

            } catch (IOException e) {

              LOG.warn("Failed to find ugi of client set_ugi() is not successful, " +

                  "Continuing without it.", e);

            } catch (TException e) {

              LOG.warn("set_ugi() not successful, Likely cause: new client talking to old server. "

                  + "Continuing without it.", e);

            }

          }

        } catch (MetaException e) {

          LOG.error("Unable to connect to metastore with URI " + store

                    + " in attempt " + attempt, e);

        }

        if (isConnected) {

          break;

        }

      }

      // Wait before launching the next round of connection retries.

      if (!isConnected && retryDelaySeconds > 0) {

        try {

          LOG.info("Waiting " + retryDelaySeconds + " seconds before next connection attempt.");

          Thread.sleep(retryDelaySeconds * 1000);

        } catch (InterruptedException ignore) {}

      }

    }

    if (!isConnected) {

      throw new MetaException("Could not connect to meta store using any of the URIs provided." +

        " Most recent failure: " + StringUtils.stringifyException(tte));

    }

    LOG.info("Connected to metastore.");

  }

  public String getTokenStrForm() throws IOException {

    return tokenStrForm;

   }

  @Override

  public void close() {

    isConnected = false;

    try {

      if (null != client) {

        client.shutdown();

      }

    } catch (TException e) {

      LOG.error("Unable to shutdown local metastore client", e);

    }

    // Transport would have got closed via client.shutdown(), so we dont need this, but

    // just in case, we make this call.

    if ((transport != null) && transport.isOpen()) {

      transport.close();

    }

  }

  /**

   * @param new_part

   * @return the added partition

   * @throws InvalidObjectException

   * @throws AlreadyExistsException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#add_partition(org.apache.hadoop.hive.metastore.api.Partition)

   */

  @Override

  public Partition add_partition(Partition new_part)

      throws InvalidObjectException, AlreadyExistsException, MetaException,

      TException {

    return add_partition(new_part, null);

  }

  public Partition add_partition(Partition new_part, EnvironmentContext envContext)

      throws InvalidObjectException, AlreadyExistsException, MetaException,

      TException {

    return deepCopy(client.add_partition_with_environment_context(new_part, envContext));

  }

  /**

   * @param new_parts

   * @throws InvalidObjectException

   * @throws AlreadyExistsException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#add_partitions(List)

   */

  @Override

  public int add_partitions(List<Partition> new_parts)

      throws InvalidObjectException, AlreadyExistsException, MetaException,

      TException {

    return client.add_partitions(new_parts);

  }

  @Override

  public List<Partition> add_partitions(

      List<Partition> parts, boolean ifNotExists, boolean needResults)

      throws InvalidObjectException, AlreadyExistsException, MetaException, TException {

    if (parts.isEmpty()) {

      return needResults ? new ArrayList<Partition>() : null;

    }

    Partition part = parts.get(0);

    AddPartitionsRequest req = new AddPartitionsRequest(

        part.getDbName(), part.getTableName(), parts, ifNotExists);

    req.setNeedResult(needResults);

    AddPartitionsResult result = client.add_partitions_req(req);

    return needResults ? result.getPartitions() : null;

  }

  /**

   * @param table_name

   * @param db_name

   * @param part_vals

   * @return the appended partition

   * @throws InvalidObjectException

   * @throws AlreadyExistsException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#append_partition(java.lang.String,

   *      java.lang.String, java.util.List)

   */

  @Override

  public Partition appendPartition(String db_name, String table_name,

      List<String> part_vals) throws InvalidObjectException,

      AlreadyExistsException, MetaException, TException {

    return appendPartition(db_name, table_name, part_vals, null);

  }

  public Partition appendPartition(String db_name, String table_name, List<String> part_vals,

      EnvironmentContext envContext) throws InvalidObjectException, AlreadyExistsException,

      MetaException, TException {

    return deepCopy(client.append_partition_with_environment_context(db_name, table_name,

        part_vals, envContext));

  }

  @Override

  public Partition appendPartition(String dbName, String tableName, String partName)

      throws InvalidObjectException, AlreadyExistsException, MetaException, TException {

    return appendPartition(dbName, tableName, partName, null);

  }

  public Partition appendPartition(String dbName, String tableName, String partName,

      EnvironmentContext envContext) throws InvalidObjectException, AlreadyExistsException,

      MetaException, TException {

    return deepCopy(client.append_partition_by_name_with_environment_context(dbName, tableName,

        partName, envContext));

  }

  /**

   * Exchange the partition between two tables

   * @param partitionSpecs partitions specs of the parent partition to be exchanged

   * @param destDb the db of the destination table

   * @param destinationTableName the destination table name

   @ @return new partition after exchanging

   */

  @Override

  public Partition exchange_partition(Map<String, String> partitionSpecs,

      String sourceDb, String sourceTable, String destDb,

      String destinationTableName) throws MetaException,

      NoSuchObjectException, InvalidObjectException, TException {

    return client.exchange_partition(partitionSpecs, sourceDb, sourceTable,

        destDb, destinationTableName);

  }

  @Override

  public void validatePartitionNameCharacters(List<String> partVals)

      throws TException, MetaException {

    client.partition_name_has_valid_characters(partVals, true);

  }

  /**

   * Create a new Database

   * @param db

   * @throws AlreadyExistsException

   * @throws InvalidObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#create_database(Database)

   */

  @Override

  public void createDatabase(Database db)

      throws AlreadyExistsException, InvalidObjectException, MetaException, TException {

    client.create_database(db);

  }

  /**

   * @param tbl

   * @throws MetaException

   * @throws NoSuchObjectException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#create_table(org.apache.hadoop.hive.metastore.api.Table)

   */

  @Override

  public void createTable(Table tbl) throws AlreadyExistsException,

      InvalidObjectException, MetaException, NoSuchObjectException, TException {

    createTable(tbl, null);

  }

  public void createTable(Table tbl, EnvironmentContext envContext) throws AlreadyExistsException,

      InvalidObjectException, MetaException, NoSuchObjectException, TException {

    HiveMetaHook hook = getHook(tbl);

    if (hook != null) {

      hook.preCreateTable(tbl);

    }

    boolean success = false;

    try {

      client.create_table_with_environment_context(tbl, envContext);

      if (hook != null) {

        hook.commitCreateTable(tbl);

      }

      success = true;

    } finally {

      if (!success && (hook != null)) {

        hook.rollbackCreateTable(tbl);

      }

    }

  }

  /**

   * @param type

   * @return true or false

   * @throws AlreadyExistsException

   * @throws InvalidObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#create_type(org.apache.hadoop.hive.metastore.api.Type)

   */

  public boolean createType(Type type) throws AlreadyExistsException,

      InvalidObjectException, MetaException, TException {

    return client.create_type(type);

  }

  /**

   * @param name

   * @throws NoSuchObjectException

   * @throws InvalidOperationException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_database(java.lang.String, boolean, boolean)

   */

  @Override

  public void dropDatabase(String name)

      throws NoSuchObjectException, InvalidOperationException, MetaException, TException {

    dropDatabase(name, true, false, false);

  }

  @Override

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

      throws NoSuchObjectException, InvalidOperationException, MetaException, TException {

    dropDatabase(name, deleteData, ignoreUnknownDb, false);

  }

  @Override

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

      throws NoSuchObjectException, InvalidOperationException, MetaException, TException {

    try {

      getDatabase(name);

    } catch (NoSuchObjectException e) {

      if (!ignoreUnknownDb) {

        throw e;

      }

      return;

    }

    if (cascade) {

       List<String> tableList = getAllTables(name);

       for (String table : tableList) {

         try {

            dropTable(name, table, deleteData, false);

         } catch (UnsupportedOperationException e) {

           // Ignore Index tables, those will be dropped with parent tables

         }

        }

    }

    client.drop_database(name, deleteData, cascade);

  }

  /**

   * @param tbl_name

   * @param db_name

   * @param part_vals

   * @return true or false

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_partition(java.lang.String,

   *      java.lang.String, java.util.List, boolean)

   */

  public boolean dropPartition(String db_name, String tbl_name,

      List<String> part_vals) throws NoSuchObjectException, MetaException,

      TException {

    return dropPartition(db_name, tbl_name, part_vals, true, null);

  }

  public boolean dropPartition(String db_name, String tbl_name, List<String> part_vals,

      EnvironmentContext env_context) throws NoSuchObjectException, MetaException, TException {

    return dropPartition(db_name, tbl_name, part_vals, true, env_context);

  }

  @Override

  public boolean dropPartition(String dbName, String tableName, String partName, boolean deleteData)

      throws NoSuchObjectException, MetaException, TException {

    return dropPartition(dbName, tableName, partName, deleteData, null);

  }

  public boolean dropPartition(String dbName, String tableName, String partName, boolean deleteData,

      EnvironmentContext envContext) throws NoSuchObjectException, MetaException, TException {

    return client.drop_partition_by_name_with_environment_context(dbName, tableName, partName,

        deleteData, envContext);

  }

  /**

   * @param db_name

   * @param tbl_name

   * @param part_vals

   * @param deleteData

   *          delete the underlying data or just delete the table in metadata

   * @return true or false

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_partition(java.lang.String,

   *      java.lang.String, java.util.List, boolean)

   */

  @Override

  public boolean dropPartition(String db_name, String tbl_name,

      List<String> part_vals, boolean deleteData) throws NoSuchObjectException,

      MetaException, TException {

    return dropPartition(db_name, tbl_name, part_vals, deleteData, null);

  }

  public boolean dropPartition(String db_name, String tbl_name, List<String> part_vals,

      boolean deleteData, EnvironmentContext envContext) throws NoSuchObjectException,

      MetaException, TException {

    return client.drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData,

        envContext);

  }

  @Override

  public List<Partition> dropPartitions(String dbName, String tblName,

      List<ObjectPair<Integer, byte[]>> partExprs, boolean deleteData, boolean ignoreProtection,

      boolean ifExists) throws NoSuchObjectException, MetaException, TException {

    RequestPartsSpec rps = new RequestPartsSpec();

    List<DropPartitionsExpr> exprs = new ArrayList<DropPartitionsExpr>(partExprs.size());

    for (ObjectPair<Integer, byte[]> partExpr : partExprs) {

      DropPartitionsExpr dpe = new DropPartitionsExpr();

      dpe.setExpr(partExpr.getSecond());

      dpe.setPartArchiveLevel(partExpr.getFirst());

      exprs.add(dpe);

    }

    rps.setExprs(exprs);

    DropPartitionsRequest req = new DropPartitionsRequest(dbName, tblName, rps);

    req.setDeleteData(deleteData);

    req.setIgnoreProtection(ignoreProtection);

    req.setNeedResult(true);

    req.setIfExists(ifExists);

    return client.drop_partitions_req(req).getPartitions();

  }

  /**

   * @param name

   * @param dbname

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_table(java.lang.String,

   *      java.lang.String, boolean)

   */

  @Override

  public void dropTable(String dbname, String name)

      throws NoSuchObjectException, MetaException, TException {

    dropTable(dbname, name, true, true, null);

  }

  /** {@inheritDoc} */

  @Override

  @Deprecated

  public void dropTable(String tableName, boolean deleteData)

      throws MetaException, UnknownTableException, TException, NoSuchObjectException {

    dropTable(DEFAULT_DATABASE_NAME, tableName, deleteData, false, null);

  }

  /**

   * @param dbname

   * @param name

   * @param deleteData

   *          delete the underlying data or just delete the table in metadata

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_table(java.lang.String,

   *      java.lang.String, boolean)

   */

  @Override

  public void dropTable(String dbname, String name, boolean deleteData,

      boolean ignoreUnknownTab) throws MetaException, TException,

      NoSuchObjectException, UnsupportedOperationException {

    dropTable(dbname, name, deleteData, ignoreUnknownTab, null);

  }

  public void dropTable(String dbname, String name, boolean deleteData,

      boolean ignoreUnknownTab, EnvironmentContext envContext) throws MetaException, TException,

      NoSuchObjectException, UnsupportedOperationException {

    Table tbl;

    try {

      tbl = getTable(dbname, name);

    } catch (NoSuchObjectException e) {

      if (!ignoreUnknownTab) {

        throw e;

      }

      return;

    }

    if (isIndexTable(tbl)) {

      throw new UnsupportedOperationException("Cannot drop index tables");

    }

    HiveMetaHook hook = getHook(tbl);

    if (hook != null) {

      hook.preDropTable(tbl);

    }

    boolean success = false;

    try {

      client.drop_table_with_environment_context(dbname, name, deleteData, envContext);

      if (hook != null) {

        hook.commitDropTable(tbl, deleteData);

      }

      success=true;

    } catch (NoSuchObjectException e) {

      if (!ignoreUnknownTab) {

        throw e;

      }

    } finally {

      if (!success && (hook != null)) {

        hook.rollbackDropTable(tbl);

      }

    }

  }

  /**

   * @param type

   * @return true if the type is dropped

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#drop_type(java.lang.String)

   */

  public boolean dropType(String type) throws NoSuchObjectException, MetaException, TException {

    return client.drop_type(type);

  }

  /**

   * @param name

   * @return map of types

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_type_all(java.lang.String)

   */

  public Map<String, Type> getTypeAll(String name) throws MetaException,

      TException {

    Map<String, Type> result = null;

    Map<String, Type> fromClient = client.get_type_all(name);

    if (fromClient != null) {

      result = new LinkedHashMap<String, Type>();

      for (String key : fromClient.keySet()) {

        result.put(key, deepCopy(fromClient.get(key)));

      }

    }

    return result;

  }

  /** {@inheritDoc} */

  @Override

  public List<String> getDatabases(String databasePattern)

    throws MetaException {

    try {

      return client.get_databases(databasePattern);

    } catch (Exception e) {

      MetaStoreUtils.logAndThrowMetaException(e);

    }

    return null;

  }

  /** {@inheritDoc} */

  @Override

  public List<String> getAllDatabases() throws MetaException {

    try {

      return client.get_all_databases();

    } catch (Exception e) {

      MetaStoreUtils.logAndThrowMetaException(e);

    }

    return null;

  }

  /**

   * @param tbl_name

   * @param db_name

   * @param max_parts

   * @return list of partitions

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   */

  @Override

  public List<Partition> listPartitions(String db_name, String tbl_name,

      short max_parts) throws NoSuchObjectException, MetaException, TException {

    return deepCopyPartitions(

        client.get_partitions(db_name, tbl_name, max_parts));

  }

  @Override

  public List<Partition> listPartitions(String db_name, String tbl_name,

      List<String> part_vals, short max_parts)

      throws NoSuchObjectException, MetaException, TException {

    return deepCopyPartitions(

        client.get_partitions_ps(db_name, tbl_name, part_vals, max_parts));

  }

  @Override

  public List<Partition> listPartitionsWithAuthInfo(String db_name,

      String tbl_name, short max_parts, String user_name, List<String> group_names)

       throws NoSuchObjectException, MetaException, TException {

    return deepCopyPartitions(

        client.get_partitions_with_auth(db_name, tbl_name, max_parts, user_name, group_names));

  }

  @Override

  public List<Partition> listPartitionsWithAuthInfo(String db_name,

      String tbl_name, List<String> part_vals, short max_parts,

      String user_name, List<String> group_names) throws NoSuchObjectException,

      MetaException, TException {

    return deepCopyPartitions(client.get_partitions_ps_with_auth(db_name,

        tbl_name, part_vals, max_parts, user_name, group_names));

  }

  /**

   * Get list of partitions matching specified filter

   * @param db_name the database name

   * @param tbl_name the table name

   * @param filter the filter string,

   *    for example "part1 = \"p1_abc\" and part2 <= "\p2_test\"". Filtering can

   *    be done only on string partition keys.

   * @param max_parts the maximum number of partitions to return,

   *    all partitions are returned if -1 is passed

   * @return list of partitions

   * @throws MetaException

   * @throws NoSuchObjectException

   * @throws TException

   */

  @Override

  public List<Partition> listPartitionsByFilter(String db_name, String tbl_name,

      String filter, short max_parts) throws MetaException,

         NoSuchObjectException, TException {

    return deepCopyPartitions(

        client.get_partitions_by_filter(db_name, tbl_name, filter, max_parts));

  }

  @Override

  public boolean listPartitionsByExpr(String db_name, String tbl_name, byte[] expr,

      String default_partition_name, short max_parts, List<Partition> result)

          throws TException {

    assert result != null;

    PartitionsByExprRequest req = new PartitionsByExprRequest(

        db_name, tbl_name, ByteBuffer.wrap(expr));

    if (default_partition_name != null) {

      req.setDefaultPartitionName(default_partition_name);

    }

    if (max_parts >= 0) {

      req.setMaxParts(max_parts);

    }

    PartitionsByExprResult r = null;

    try {

      r = client.get_partitions_by_expr(req);

    } catch (TApplicationException te) {

      // TODO: backward compat for Hive <= 0.12. Can be removed later.

      if (te.getType() != TApplicationException.UNKNOWN_METHOD

          && te.getType() != TApplicationException.WRONG_METHOD_NAME) {

        throw te;

      }

      throw new IncompatibleMetastoreException(

          "Metastore doesn't support listPartitionsByExpr: " + te.getMessage());

    }

    // TODO: in these methods, do we really need to deepcopy?

    deepCopyPartitions(r.getPartitions(), result);

    return !r.isSetHasUnknownPartitions() || r.isHasUnknownPartitions(); // Assume the worst.

  }

  /**

   * @param name

   * @return the database

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_database(java.lang.String)

   */

  @Override

  public Database getDatabase(String name) throws NoSuchObjectException,

      MetaException, TException {

    return deepCopy(client.get_database(name));

  }

  /**

   * @param tbl_name

   * @param db_name

   * @param part_vals

   * @return the partition

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_partition(java.lang.String,

   *      java.lang.String, java.util.List)

   */

  @Override

  public Partition getPartition(String db_name, String tbl_name,

      List<String> part_vals) throws NoSuchObjectException, MetaException, TException {

    return deepCopy(client.get_partition(db_name, tbl_name, part_vals));

  }

  @Override

  public List<Partition> getPartitionsByNames(String db_name, String tbl_name,

      List<String> part_names) throws NoSuchObjectException, MetaException, TException {

    return deepCopyPartitions(client.get_partitions_by_names(db_name, tbl_name, part_names));

  }

  @Override

  public Partition getPartitionWithAuthInfo(String db_name, String tbl_name,

      List<String> part_vals, String user_name, List<String> group_names)

      throws MetaException, UnknownTableException, NoSuchObjectException,

      TException {

    return deepCopy(client.get_partition_with_auth(db_name, tbl_name, part_vals, user_name,

        group_names));

  }

  /**

   * @param name

   * @param dbname

   * @return the table

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   * @throws NoSuchObjectException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_table(java.lang.String,

   *      java.lang.String)

   */

  @Override

  public Table getTable(String dbname, String name) throws MetaException,

      TException, NoSuchObjectException {

    return deepCopy(client.get_table(dbname, name));

  }

  /** {@inheritDoc} */

  @Override

  @Deprecated

  public Table getTable(String tableName) throws MetaException, TException,

      NoSuchObjectException {

    return getTable(DEFAULT_DATABASE_NAME, tableName);

  }

  /** {@inheritDoc} */

  @Override

  public List<Table> getTableObjectsByName(String dbName, List<String> tableNames)

      throws MetaException, InvalidOperationException, UnknownDBException, TException {

    return deepCopyTables(client.get_table_objects_by_name(dbName, tableNames));

  }

  /** {@inheritDoc} */

  @Override

  public List<String> listTableNamesByFilter(String dbName, String filter, short maxTables)

      throws MetaException, TException, InvalidOperationException, UnknownDBException {

    return client.get_table_names_by_filter(dbName, filter, maxTables);

  }

  /**

   * @param name

   * @return the type

   * @throws MetaException

   * @throws TException

   * @throws NoSuchObjectException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_type(java.lang.String)

   */

  public Type getType(String name) throws NoSuchObjectException, MetaException, TException {

    return deepCopy(client.get_type(name));

  }

  /** {@inheritDoc} */

  @Override

  public List<String> getTables(String dbname, String tablePattern) throws MetaException {

    try {

      return client.get_tables(dbname, tablePattern);

    } catch (Exception e) {

      MetaStoreUtils.logAndThrowMetaException(e);

    }

    return null;

  }

  /** {@inheritDoc} */

  @Override

  public List<String> getAllTables(String dbname) throws MetaException {

    try {

      return client.get_all_tables(dbname);

    } catch (Exception e) {

      MetaStoreUtils.logAndThrowMetaException(e);

    }

    return null;

  }

  @Override

  public boolean tableExists(String databaseName, String tableName) throws MetaException,

      TException, UnknownDBException {

    try {

      client.get_table(databaseName, tableName);

    } catch (NoSuchObjectException e) {

      return false;

    }

    return true;

  }

  /** {@inheritDoc} */

  @Override

  @Deprecated

  public boolean tableExists(String tableName) throws MetaException,

      TException, UnknownDBException {

    return tableExists(DEFAULT_DATABASE_NAME, tableName);

  }

  @Override

  public List<String> listPartitionNames(String dbName, String tblName,

      short max) throws MetaException, TException {

    return client.get_partition_names(dbName, tblName, max);

  }

  @Override

  public List<String> listPartitionNames(String db_name, String tbl_name,

      List<String> part_vals, short max_parts)

      throws MetaException, TException, NoSuchObjectException {

    return client.get_partition_names_ps(db_name, tbl_name, part_vals, max_parts);

  }

  @Override

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

      throws InvalidOperationException, MetaException, TException {

    client.alter_partition(dbName, tblName, newPart);

  }

  @Override

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

  throws InvalidOperationException, MetaException, TException {

    client.alter_partitions(dbName, tblName, newParts);

  @Override

  public void alterDatabase(String dbName, Database db)

      throws MetaException, NoSuchObjectException, TException {

    client.alter_database(dbName, db);

  }

  /**

   * @param db

   * @param tableName

   * @throws UnknownTableException

   * @throws UnknownDBException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#get_fields(java.lang.String,

   *      java.lang.String)

   */

  @Override

  public List<FieldSchema> getFields(String db, String tableName)

      throws MetaException, TException, UnknownTableException,

      UnknownDBException {

    return deepCopyFieldSchemas(client.get_fields(db, tableName));

  }

  /**

   * create an index

   * @param index the index object

   * @param indexTable which stores the index data

   * @throws InvalidObjectException

   * @throws MetaException

   * @throws NoSuchObjectException

   * @throws TException

   * @throws AlreadyExistsException

   */

  @Override

  public void createIndex(Index index, Table indexTable) throws AlreadyExistsException, InvalidObjectException, MetaException, NoSuchObjectException, TException {

    client.add_index(index, indexTable);

  }

  /**

   * @param dbname

   * @param base_tbl_name

   * @param idx_name

   * @param new_idx

   * @throws InvalidOperationException

   * @throws MetaException

   * @throws TException

   * @see org.apache.hadoop.hive.metastore.api.ThriftHiveMetastore.Iface#alter_index(java.lang.String,

   *      java.lang.String, java.lang.String, org.apache.hadoop.hive.metastore.api.Index)

   */

  @Override

  public void alter_index(String dbname, String base_tbl_name, String idx_name, Index new_idx)

      throws InvalidOperationException, MetaException, TException {

    client.alter_index(dbname, base_tbl_name, idx_name, new_idx);

  }

  /**

   * @param dbName

   * @param tblName

   * @param indexName

   * @return the index

   * @throws MetaException

   * @throws UnknownTableException

   * @throws NoSuchObjectException

   * @throws TException

   */

  @Override

  public Index getIndex(String dbName, String tblName, String indexName)

      throws MetaException, UnknownTableException, NoSuchObjectException,

      TException {

    return deepCopy(client.get_index_by_name(dbName, tblName, indexName));

  }

  /**

   * list indexes of the give base table

   * @param dbName

   * @param tblName

   * @param max

   * @return the list of indexes

   * @throws NoSuchObjectException

   * @throws MetaException

   * @throws TException

   */

  @Override

  public List<String> listIndexNames(String dbName, String tblName, short max)

      throws MetaException, TException {

    return client.get_index_names(dbName, tblName, max);

  }

  /**

   * list all the index names of the give base table.

   *

   * @param dbName

   * @param tblName

   * @param max

   * @return list of indexes

   * @throws MetaException

   * @throws TException

   */

  @Override

  public List<Index> listIndexes(String dbName, String tblName, short max)

      throws NoSuchObjectException, MetaException, TException {

    return client.get_indexes(dbName, tblName, max);

  }

  /** {@inheritDoc} */

  @Override

  public boolean updateTableColumnStatistics(ColumnStatistics statsObj)

    throws NoSuchObjectException, InvalidObjectException, MetaException, TException,

    InvalidInputException{

    return client.update_table_column_statistics(statsObj);

  }

  /** {@inheritDoc} */

  @Override

  public boolean updatePartitionColumnStatistics(ColumnStatistics statsObj)

    throws NoSuchObjectException, InvalidObjectException, MetaException, TException,

    InvalidInputException{

    return client.update_partition_column_statistics(statsObj);

  }

  /** {@inheritDoc} */

  @Override

  public List<ColumnStatisticsObj> getTableColumnStatistics(String dbName, String tableName,

      List<String> colNames) throws NoSuchObjectException, MetaException, TException,

      InvalidInputException, InvalidObjectException {

    return client.get_table_statistics_req(

        new TableStatsRequest(dbName, tableName, colNames)).getTableStats();

  }

  /** {@inheritDoc} */

  @Override

  public Map<String, List<ColumnStatisticsObj>> getPartitionColumnStatistics(

      String dbName, String tableName, List<String> partNames, List<String> colNames)

          throws NoSuchObjectException, MetaException, TException {

    return client.get_partitions_statistics_req(

        new PartitionsStatsRequest(dbName, tableName, colNames, partNames)).getPartStats();

  }

  /** {@inheritDoc} */

  @Override

  public boolean deletePartitionColumnStatistics(String dbName, String tableName, String partName,

    String colName) throws NoSuchObjectException, InvalidObjectException, MetaException,

    TException, InvalidInputException

  {

    return client.delete_partition_column_statistics(dbName, tableName, partName, colName);

  }

  /** {@inheritDoc} */

  @Override

  public boolean deleteTableColumnStatistics(String dbName, String tableName, String colName)

    throws NoSuchObjectException, InvalidObjectException, MetaException, TException,

    InvalidInputException

  {

    return client.delete_table_column_statistics(dbName, tableName, colName);

  }

  /**

   * @param db

   * @param tableName

   * @throws UnknownTableException

   * @throws UnknownDBException