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

*/

  protected static HiveMetaStoreClient client;

  protected static HiveConf hiveConf;

  protected static Warehouse warehouse;

  protected static boolean isThriftClient = false;

  private static final String TEST_DB1_NAME = "testdb1";

  private static final String TEST_DB2_NAME = "testdb2";

  @Override

  protected void setUp() throws Exception {

    hiveConf = new HiveConf(this.getClass());

    warehouse = new Warehouse(hiveConf);

    // set some values to use for getting conf. vars

    hiveConf.set("hive.metastore.metrics.enabled","true");

    hiveConf.set("hive.key1", "value1");

    hiveConf.set("hive.key2", "http://www.example.com");

    hiveConf.set("hive.key3", "");

    hiveConf.set("hive.key4", "0");

  }

  public void testNameMethods() {

    Map<String, String> spec = new LinkedHashMap<String, String>();

    spec.put("ds", "2008-07-01 14:13:12");

    spec.put("hr", "14");

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

    for(String v : spec.values()) {

      vals.add(v);

    }

    String partName = "ds=2008-07-01 14%3A13%3A12/hr=14";

    try {

      List<String> testVals = client.partitionNameToVals(partName);

      assertTrue("Values from name are incorrect", vals.equals(testVals));

      Map<String, String> testSpec = client.partitionNameToSpec(partName);

      assertTrue("Spec from name is incorrect", spec.equals(testSpec));

      List<String> emptyVals = client.partitionNameToVals("");

      assertTrue("Values should be empty", emptyVals.size() == 0);

      Map<String, String> emptySpec =  client.partitionNameToSpec("");

      assertTrue("Spec should be empty", emptySpec.size() == 0);

    } catch (Exception e) {

      assert(false);

    }

  }

  /**

   * tests create table and partition and tries to drop the table without

   * droppping the partition

   *

   * @throws Exception

   */

  public void testPartition() throws Exception {

    partitionTester(client, hiveConf);

  }

  public static void partitionTester(HiveMetaStoreClient client, HiveConf hiveConf)

    throws Exception {

    try {

      String dbName = "compdb";

      String tblName = "comptbl";

      String typeName = "Person";

      List<String> vals = makeVals("2008-07-01 14:13:12", "14");

      List<String> vals2 = makeVals("2008-07-01 14:13:12", "15");

      List<String> vals3 = makeVals("2008-07-02 14:13:12", "15");

      List<String> vals4 = makeVals("2008-07-03 14:13:12", "151");

      client.dropTable(dbName, tblName);

      silentDropDatabase(dbName);

      Database db = new Database();

      db.setName(dbName);

      client.createDatabase(db);

      client.dropType(typeName);

      Type typ1 = new Type();

      typ1.setName(typeName);

      typ1.setFields(new ArrayList<FieldSchema>(2));

      typ1.getFields().add(

          new FieldSchema("name", Constants.STRING_TYPE_NAME, ""));

      typ1.getFields().add(

          new FieldSchema("income", Constants.INT_TYPE_NAME, ""));

      client.createType(typ1);

      Table tbl = new Table();

      tbl.setDbName(dbName);

      tbl.setTableName(tblName);

      StorageDescriptor sd = new StorageDescriptor();

      tbl.setSd(sd);

      sd.setCols(typ1.getFields());

      sd.setCompressed(false);

      sd.setNumBuckets(1);

      sd.setParameters(new HashMap<String, String>());

      sd.getParameters().put("test_param_1", "Use this for comments etc");

      sd.setBucketCols(new ArrayList<String>(2));

      sd.getBucketCols().add("name");

      sd.setSerdeInfo(new SerDeInfo());

      sd.getSerdeInfo().setName(tbl.getTableName());

      sd.getSerdeInfo().setParameters(new HashMap<String, String>());

      sd.getSerdeInfo().getParameters()

          .put(Constants.SERIALIZATION_FORMAT, "1");

      sd.setSortCols(new ArrayList<Order>());

      tbl.setPartitionKeys(new ArrayList<FieldSchema>(2));

      tbl.getPartitionKeys().add(

          new FieldSchema("ds", Constants.STRING_TYPE_NAME, ""));

      tbl.getPartitionKeys().add(

          new FieldSchema("hr", Constants.STRING_TYPE_NAME, ""));

      client.createTable(tbl);

      if (isThriftClient) {

        // the createTable() above does not update the location in the 'tbl'

        // object when the client is a thrift client and the code below relies

        // on the location being present in the 'tbl' object - so get the table

        // from the metastore

        tbl = client.getTable(dbName, tblName);

      }

      Partition part = makePartitionObject(dbName, tblName, vals, tbl, "/part1");

      Partition part2 = makePartitionObject(dbName, tblName, vals2, tbl, "/part2");

      Partition part3 = makePartitionObject(dbName, tblName, vals3, tbl, "/part3");

      Partition part4 = makePartitionObject(dbName, tblName, vals4, tbl, "/part4");

      // check if the partition exists (it shouldn't)

      boolean exceptionThrown = false;

      try {

        Partition p = client.getPartition(dbName, tblName, vals);

      } catch(Exception e) {

        assertEquals("partition should not have existed",

            NoSuchObjectException.class, e.getClass());

        exceptionThrown = true;

      }

      assertTrue("getPartition() should have thrown NoSuchObjectException", exceptionThrown);

      Partition retp = client.add_partition(part);

      assertNotNull("Unable to create partition " + part, retp);

      Partition retp2 = client.add_partition(part2);

      assertNotNull("Unable to create partition " + part2, retp2);

      Partition retp3 = client.add_partition(part3);

      assertNotNull("Unable to create partition " + part3, retp3);

      Partition retp4 = client.add_partition(part4);

      assertNotNull("Unable to create partition " + part4, retp4);

      Partition part_get = client.getPartition(dbName, tblName, part.getValues());

      if(isThriftClient) {

        // since we are using thrift, 'part' will not have the create time and

        // last DDL time set since it does not get updated in the add_partition()

        // call - likewise part2 and part3 - set it correctly so that equals check

        // doesn't fail

        adjust(client, part, dbName, tblName);

        adjust(client, part2, dbName, tblName);

        adjust(client, part3, dbName, tblName);

      }

      assertTrue("Partitions are not same", part.equals(part_get));

      String partName = "ds=2008-07-01 14%3A13%3A12/hr=14";

      String part2Name = "ds=2008-07-01 14%3A13%3A12/hr=15";

      String part3Name ="ds=2008-07-02 14%3A13%3A12/hr=15";

      String part4Name ="ds=2008-07-03 14%3A13%3A12/hr=151";

      part_get = client.getPartition(dbName, tblName, partName);

      assertTrue("Partitions are not the same", part.equals(part_get));

      // Test partition listing with a partial spec - ds is specified but hr is not

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

      partialVals.add(vals.get(0));

      Set<Partition> parts = new HashSet<Partition>();

      parts.add(part);

      parts.add(part2);

      List<Partition> partial = client.listPartitions(dbName, tblName, partialVals,

          (short) -1);

      assertTrue("Should have returned 2 partitions", partial.size() == 2);

      assertTrue("Not all parts returned", partial.containsAll(parts));

      Set<String> partNames = new HashSet<String>();

      partNames.add(partName);

      partNames.add(part2Name);

      List<String> partialNames = client.listPartitionNames(dbName, tblName, partialVals,

          (short) -1);

      assertTrue("Should have returned 2 partition names", partialNames.size() == 2);

      assertTrue("Not all part names returned", partialNames.containsAll(partNames));

      partNames.add(part3Name);

      partNames.add(part4Name);

      partialVals.clear();

      partialVals.add("");

      partialNames = client.listPartitionNames(dbName, tblName, partialVals, (short) -1);

      assertTrue("Should have returned 4 partition names", partialNames.size() == 4);

      assertTrue("Not all part names returned", partialNames.containsAll(partNames));

      // Test partition listing with a partial spec - hr is specified but ds is not

      parts.clear();

      parts.add(part2);

      parts.add(part3);

      partialVals.clear();

      partialVals.add("");

      partialVals.add(vals2.get(1));

      partial = client.listPartitions(dbName, tblName, partialVals, (short) -1);

      assertEquals("Should have returned 2 partitions", 2, partial.size());

      assertTrue("Not all parts returned", partial.containsAll(parts));

      partNames.clear();

      partNames.add(part2Name);

      partNames.add(part3Name);

      partialNames = client.listPartitionNames(dbName, tblName, partialVals,

          (short) -1);

      assertEquals("Should have returned 2 partition names", 2, partialNames.size());

      assertTrue("Not all part names returned", partialNames.containsAll(partNames));

      // Verify escaped partition names don't return partitions

      exceptionThrown = false;

      try {

        String badPartName = "ds=2008-07-01 14%3A13%3A12/hrs=14";

        client.getPartition(dbName, tblName, badPartName);

      } catch(NoSuchObjectException e) {

        exceptionThrown = true;

      }

      assertTrue("Bad partition spec should have thrown an exception", exceptionThrown);

      Path partPath = new Path(part.getSd().getLocation());

      FileSystem fs = FileSystem.get(partPath.toUri(), hiveConf);

      assertTrue(fs.exists(partPath));

      client.dropPartition(dbName, tblName, part.getValues(), true);

      assertFalse(fs.exists(partPath));

      // Test append_partition_by_name

      client.appendPartition(dbName, tblName, partName);

      Partition part5 = client.getPartition(dbName, tblName, part.getValues());

      assertTrue("Append partition by name failed", part5.getValues().equals(vals));;

      Path part5Path = new Path(part5.getSd().getLocation());

      assertTrue(fs.exists(part5Path));

      // Test drop_partition_by_name

      assertTrue("Drop partition by name failed",

          client.dropPartition(dbName, tblName, partName, true));

      assertFalse(fs.exists(part5Path));

      // add the partition again so that drop table with a partition can be

      // tested

      retp = client.add_partition(part);

      assertNotNull("Unable to create partition " + part, retp);

      // test add_partitions

      List<String> mvals1 = makeVals("2008-07-04 14:13:12", "14641");

      List<String> mvals2 = makeVals("2008-07-04 14:13:12", "14642");

      List<String> mvals3 = makeVals("2008-07-04 14:13:12", "14643");

      List<String> mvals4 = makeVals("2008-07-04 14:13:12", "14643"); // equal to 3

      List<String> mvals5 = makeVals("2008-07-04 14:13:12", "14645");

      Exception savedException;

      // add_partitions(empty list) : ok, normal operation

      client.add_partitions(new ArrayList<Partition>());

      // add_partitions(1,2,3) : ok, normal operation

      Partition mpart1 = makePartitionObject(dbName, tblName, mvals1, tbl, "/mpart1");

      Partition mpart2 = makePartitionObject(dbName, tblName, mvals2, tbl, "/mpart2");

      Partition mpart3 = makePartitionObject(dbName, tblName, mvals3, tbl, "/mpart3");

      client.add_partitions(Arrays.asList(mpart1,mpart2,mpart3));

      if(isThriftClient) {

        // do DDL time munging if thrift mode

        adjust(client, mpart1, dbName, tblName);

        adjust(client, mpart2, dbName, tblName);

        adjust(client, mpart3, dbName, tblName);

      }

      verifyPartitionsPublished(client, dbName, tblName,

          Arrays.asList(mvals1.get(0)),

          Arrays.asList(mpart1,mpart2,mpart3));

      Partition mpart4 = makePartitionObject(dbName, tblName, mvals4, tbl, "/mpart4");

      Partition mpart5 = makePartitionObject(dbName, tblName, mvals5, tbl, "/mpart5");

      // create dir for /mpart5

      Path mp5Path = new Path(mpart5.getSd().getLocation());

      warehouse.mkdirs(mp5Path);

      assertTrue(fs.exists(mp5Path));

      // add_partitions(5,4) : err = duplicate keyvals on mpart4

      savedException = null;

      try {

        client.add_partitions(Arrays.asList(mpart5,mpart4));

      } catch (Exception e) {

        savedException = e;

      } finally {

        assertNotNull(savedException);

      }

      // check that /mpart4 does not exist, but /mpart5 still does.

      assertTrue(fs.exists(mp5Path));

      assertFalse(fs.exists(new Path(mpart4.getSd().getLocation())));

      // add_partitions(5) : ok

      client.add_partitions(Arrays.asList(mpart5));

      if(isThriftClient) {

        // do DDL time munging if thrift mode

        adjust(client, mpart5, dbName, tblName);

      }

      verifyPartitionsPublished(client, dbName, tblName,

          Arrays.asList(mvals1.get(0)),

          Arrays.asList(mpart1,mpart2,mpart3,mpart5));

      //// end add_partitions tests

      client.dropTable(dbName, tblName);

      client.dropType(typeName);

      // recreate table as external, drop partition and it should

      // still exist

      tbl.setParameters(new HashMap<String, String>());

      tbl.getParameters().put("EXTERNAL", "TRUE");

      client.createTable(tbl);

      retp = client.add_partition(part);

      assertTrue(fs.exists(partPath));

      client.dropPartition(dbName, tblName, part.getValues(), true);

      assertTrue(fs.exists(partPath));

      for (String tableName : client.getTables(dbName, "*")) {

        client.dropTable(dbName, tableName);

      }

      client.dropDatabase(dbName);

    } catch (Exception e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testPartition() failed.");

      throw e;

    }

  }

  private static void verifyPartitionsPublished(HiveMetaStoreClient client,

      String dbName, String tblName, List<String> partialSpec,

      List<Partition> expectedPartitions)

          throws NoSuchObjectException, MetaException, TException {

    // Test partition listing with a partial spec

    List<Partition> mpartial = client.listPartitions(dbName, tblName, partialSpec,

        (short) -1);

    assertEquals("Should have returned "+expectedPartitions.size()+

        " partitions, returned " + mpartial.size(),

        expectedPartitions.size(), mpartial.size());

    assertTrue("Not all parts returned", mpartial.containsAll(expectedPartitions));

  }

  private static List<String> makeVals(String ds, String id) {

    List <String> vals4 = new ArrayList<String>(2);

    vals4 = new ArrayList<String>(2);

    vals4.add(ds);

    vals4.add(id);

    return vals4;

  }

  private static Partition makePartitionObject(String dbName, String tblName,

      List<String> ptnVals, Table tbl, String ptnLocationSuffix) {

    Partition part4 = new Partition();

    part4.setDbName(dbName);

    part4.setTableName(tblName);

    part4.setValues(ptnVals);

    part4.setParameters(new HashMap<String, String>());

    part4.setSd(tbl.getSd().deepCopy());

    part4.getSd().setSerdeInfo(tbl.getSd().getSerdeInfo().deepCopy());

    part4.getSd().setLocation(tbl.getSd().getLocation() + ptnLocationSuffix);

    return part4;

  }

  public void testAlterPartition() throws Throwable {

    try {

      String dbName = "compdb";

      String tblName = "comptbl";

      List<String> vals = new ArrayList<String>(2);

      vals.add("2008-07-01");

      vals.add("14");

      client.dropTable(dbName, tblName);

      silentDropDatabase(dbName);

      Database db = new Database();

      db.setName(dbName);

      db.setDescription("Alter Partition Test database");

      client.createDatabase(db);

      ArrayList<FieldSchema> cols = new ArrayList<FieldSchema>(2);

      cols.add(new FieldSchema("name", Constants.STRING_TYPE_NAME, ""));

      cols.add(new FieldSchema("income", Constants.INT_TYPE_NAME, ""));

      Table tbl = new Table();

      tbl.setDbName(dbName);

      tbl.setTableName(tblName);

      StorageDescriptor sd = new StorageDescriptor();

      tbl.setSd(sd);

      sd.setCols(cols);

      sd.setCompressed(false);

      sd.setNumBuckets(1);

      sd.setParameters(new HashMap<String, String>());

      sd.getParameters().put("test_param_1", "Use this for comments etc");

      sd.setBucketCols(new ArrayList<String>(2));

      sd.getBucketCols().add("name");

      sd.setSerdeInfo(new SerDeInfo());

      sd.getSerdeInfo().setName(tbl.getTableName());

      sd.getSerdeInfo().setParameters(new HashMap<String, String>());

      sd.getSerdeInfo().getParameters()

          .put(Constants.SERIALIZATION_FORMAT, "1");

      sd.setSortCols(new ArrayList<Order>());

      tbl.setPartitionKeys(new ArrayList<FieldSchema>(2));

      tbl.getPartitionKeys().add(

          new FieldSchema("ds", Constants.STRING_TYPE_NAME, ""));

      tbl.getPartitionKeys().add(

          new FieldSchema("hr", Constants.INT_TYPE_NAME, ""));

      client.createTable(tbl);

      if (isThriftClient) {

        // the createTable() above does not update the location in the 'tbl'

        // object when the client is a thrift client and the code below relies

        // on the location being present in the 'tbl' object - so get the table

        // from the metastore

        tbl = client.getTable(dbName, tblName);

      }

      Partition part = new Partition();

      part.setDbName(dbName);

      part.setTableName(tblName);

      part.setValues(vals);

      part.setParameters(new HashMap<String, String>());

      part.setSd(tbl.getSd());

      part.getSd().setSerdeInfo(tbl.getSd().getSerdeInfo());

      part.getSd().setLocation(tbl.getSd().getLocation() + "/part1");

      client.add_partition(part);

      Partition part2 = client.getPartition(dbName, tblName, part.getValues());

      part2.getParameters().put("retention", "10");

      part2.getSd().setNumBuckets(12);

      part2.getSd().getSerdeInfo().getParameters().put("abc", "1");

      client.alter_partition(dbName, tblName, part2);

      Partition part3 = client.getPartition(dbName, tblName, part.getValues());

      assertEquals("couldn't alter partition", part3.getParameters().get(

          "retention"), "10");

      assertEquals("couldn't alter partition", part3.getSd().getSerdeInfo()

          .getParameters().get("abc"), "1");

      assertEquals("couldn't alter partition", part3.getSd().getNumBuckets(),

          12);

      client.dropTable(dbName, tblName);

      client.dropDatabase(dbName);

    } catch (Exception e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testPartition() failed.");

      throw e;

    }

  }

  public void testRenamePartition() throws Throwable {

    try {

      String dbName = "compdb1";

      String tblName = "comptbl1";

      List<String> vals = new ArrayList<String>(2);

      vals.add("2011-07-11");

      vals.add("8");

      String part_path = "/ds=2011-07-11/hr=8";

      List<String> tmp_vals = new ArrayList<String>(2);

      tmp_vals.add("tmp_2011-07-11");

      tmp_vals.add("-8");

      String part2_path = "/ds=tmp_2011-07-11/hr=-8";

      client.dropTable(dbName, tblName);

      silentDropDatabase(dbName);

      Database db = new Database();

      db.setName(dbName);

      db.setDescription("Rename Partition Test database");

      client.createDatabase(db);

      ArrayList<FieldSchema> cols = new ArrayList<FieldSchema>(2);

      cols.add(new FieldSchema("name", Constants.STRING_TYPE_NAME, ""));

      cols.add(new FieldSchema("income", Constants.INT_TYPE_NAME, ""));

      Table tbl = new Table();

      tbl.setDbName(dbName);

      tbl.setTableName(tblName);

      StorageDescriptor sd = new StorageDescriptor();

      tbl.setSd(sd);

      sd.setCols(cols);

      sd.setCompressed(false);

      sd.setNumBuckets(1);

      sd.setParameters(new HashMap<String, String>());

      sd.getParameters().put("test_param_1", "Use this for comments etc");

      sd.setBucketCols(new ArrayList<String>(2));

      sd.getBucketCols().add("name");

      sd.setSerdeInfo(new SerDeInfo());

      sd.getSerdeInfo().setName(tbl.getTableName());

      sd.getSerdeInfo().setParameters(new HashMap<String, String>());

      sd.getSerdeInfo().getParameters()

          .put(Constants.SERIALIZATION_FORMAT, "1");

      sd.setSortCols(new ArrayList<Order>());

      tbl.setPartitionKeys(new ArrayList<FieldSchema>(2));

      tbl.getPartitionKeys().add(

          new FieldSchema("ds", Constants.STRING_TYPE_NAME, ""));

      tbl.getPartitionKeys().add(

          new FieldSchema("hr", Constants.INT_TYPE_NAME, ""));

      client.createTable(tbl);

      if (isThriftClient) {

        // the createTable() above does not update the location in the 'tbl'

        // object when the client is a thrift client and the code below relies

        // on the location being present in the 'tbl' object - so get the table

        // from the metastore

        tbl = client.getTable(dbName, tblName);

      }

      Partition part = new Partition();

      part.setDbName(dbName);

      part.setTableName(tblName);

      part.setValues(vals);

      part.setParameters(new HashMap<String, String>());

      part.setSd(tbl.getSd().deepCopy());

      part.getSd().setSerdeInfo(tbl.getSd().getSerdeInfo());

      part.getSd().setLocation(tbl.getSd().getLocation() + "/part1");

      part.getParameters().put("retention", "10");

      part.getSd().setNumBuckets(12);

      part.getSd().getSerdeInfo().getParameters().put("abc", "1");

      client.add_partition(part);

      part.setValues(tmp_vals);

      client.renamePartition(dbName, tblName, vals, part);

      boolean exceptionThrown = false;

      try {

        Partition p = client.getPartition(dbName, tblName, vals);

      } catch(Exception e) {

        assertEquals("partition should not have existed",

            NoSuchObjectException.class, e.getClass());

        exceptionThrown = true;

      }

      assertTrue("Expected NoSuchObjectException", exceptionThrown);

      Partition part3 = client.getPartition(dbName, tblName, tmp_vals);

      assertEquals("couldn't rename partition", part3.getParameters().get(

          "retention"), "10");

      assertEquals("couldn't rename partition", part3.getSd().getSerdeInfo()

          .getParameters().get("abc"), "1");

      assertEquals("couldn't rename partition", part3.getSd().getNumBuckets(),

          12);

      assertEquals("new partition sd matches", part3.getSd().getLocation(),

          tbl.getSd().getLocation() + part2_path);

      part.setValues(vals);

      client.renamePartition(dbName, tblName, tmp_vals, part);

      exceptionThrown = false;

      try {

        Partition p = client.getPartition(dbName, tblName, tmp_vals);

      } catch(Exception e) {

        assertEquals("partition should not have existed",

            NoSuchObjectException.class, e.getClass());

        exceptionThrown = true;

      }

      assertTrue("Expected NoSuchObjectException", exceptionThrown);

      part3 = client.getPartition(dbName, tblName, vals);

      assertEquals("couldn't rename partition", part3.getParameters().get(

          "retention"), "10");

      assertEquals("couldn't rename partition", part3.getSd().getSerdeInfo()

          .getParameters().get("abc"), "1");

      assertEquals("couldn't rename partition", part3.getSd().getNumBuckets(),

          12);

      assertEquals("new partition sd matches", part3.getSd().getLocation(),

          tbl.getSd().getLocation() + part_path);

      client.dropTable(dbName, tblName);

      client.dropDatabase(dbName);

    } catch (Exception e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testRenamePartition() failed.");

      throw e;

    }

  }

  public void testDatabase() throws Throwable {

    try {

      // clear up any existing databases

      silentDropDatabase(TEST_DB1_NAME);

      silentDropDatabase(TEST_DB2_NAME);

      Database db = new Database();

      db.setName(TEST_DB1_NAME);

      client.createDatabase(db);

      db = client.getDatabase(TEST_DB1_NAME);

      assertEquals("name of returned db is different from that of inserted db",

          TEST_DB1_NAME, db.getName());

      assertEquals("location of the returned db is different from that of inserted db",

          warehouse.getDatabasePath(db).toString(), db.getLocationUri());

      Database db2 = new Database();

      db2.setName(TEST_DB2_NAME);

      client.createDatabase(db2);

      db2 = client.getDatabase(TEST_DB2_NAME);

      assertEquals("name of returned db is different from that of inserted db",

          TEST_DB2_NAME, db2.getName());

      assertEquals("location of the returned db is different from that of inserted db",

          warehouse.getDatabasePath(db2).toString(), db2.getLocationUri());

      List<String> dbs = client.getDatabases(".*");

      assertTrue("first database is not " + TEST_DB1_NAME, dbs.contains(TEST_DB1_NAME));

      assertTrue("second database is not " + TEST_DB2_NAME, dbs.contains(TEST_DB2_NAME));

      client.dropDatabase(TEST_DB1_NAME);

      client.dropDatabase(TEST_DB2_NAME);

      silentDropDatabase(TEST_DB1_NAME);

      silentDropDatabase(TEST_DB2_NAME);

    } catch (Throwable e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testDatabase() failed.");

      throw e;

    }

  }

  public void testDatabaseLocation() throws Throwable {

    try {

      // clear up any existing databases

      silentDropDatabase(TEST_DB1_NAME);

      Database db = new Database();

      db.setName(TEST_DB1_NAME);

      String dbLocation =

          HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/_testDB_create_";

      db.setLocationUri(dbLocation);

      client.createDatabase(db);

      db = client.getDatabase(TEST_DB1_NAME);

      assertEquals("name of returned db is different from that of inserted db",

          TEST_DB1_NAME, db.getName());

      assertEquals("location of the returned db is different from that of inserted db",

          warehouse.getDnsPath(new Path(dbLocation)).toString(), db.getLocationUri());

      client.dropDatabase(TEST_DB1_NAME);

      silentDropDatabase(TEST_DB1_NAME);

      db = new Database();

      db.setName(TEST_DB1_NAME);

      dbLocation =

          HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/test/_testDB_create_";

      FileSystem fs = FileSystem.get(new Path(dbLocation).toUri(), hiveConf);

      fs.mkdirs(

          new Path(HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/test"),

          new FsPermission((short) 0));

      db.setLocationUri(dbLocation);

      boolean createFailed = false;

      try {

        client.createDatabase(db);

      } catch (MetaException cantCreateDB) {

        createFailed = true;

      }

      assertTrue("Database creation succeeded even with permission problem", createFailed);

      boolean objectNotExist = false;

      try {

        client.getDatabase(TEST_DB1_NAME);

      } catch (NoSuchObjectException e) {

        objectNotExist = true;

      }

      assertTrue("Database " + TEST_DB1_NAME + " exists ", objectNotExist);

      // Cleanup

      fs.setPermission(

          new Path(HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/test"),

          new FsPermission((short) 755));

      fs.delete(new Path(HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/test"), true);

      db = new Database();

      db.setName(TEST_DB1_NAME);

      dbLocation =

          HiveConf.getVar(hiveConf, HiveConf.ConfVars.METASTOREWAREHOUSE) + "/_testDB_file_";

      fs = FileSystem.get(new Path(dbLocation).toUri(), hiveConf);

      fs.createNewFile(new Path(dbLocation));

      fs.deleteOnExit(new Path(dbLocation));

      db.setLocationUri(dbLocation);

      createFailed = false;

      try {

        client.createDatabase(db);

      } catch (MetaException cantCreateDB) {

        System.err.println(cantCreateDB.getMessage());

        createFailed = true;

      }

      assertTrue("Database creation succeeded even location exists and is a file", createFailed);

      objectNotExist = false;

      try {

        client.getDatabase(TEST_DB1_NAME);

      } catch (NoSuchObjectException e) {

        objectNotExist = true;

      }

      assertTrue("Database " + TEST_DB1_NAME + " exists when location is specified and is a file",

          objectNotExist);

    } catch (Throwable e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testDatabaseLocation() failed.");

      throw e;

    }

  }

  public void testSimpleTypeApi() throws Exception {

    try {

      client.dropType(Constants.INT_TYPE_NAME);

      Type typ1 = new Type();

      typ1.setName(Constants.INT_TYPE_NAME);

      boolean ret = client.createType(typ1);

      assertTrue("Unable to create type", ret);

      Type typ1_2 = client.getType(Constants.INT_TYPE_NAME);

      assertNotNull(typ1_2);

      assertEquals(typ1.getName(), typ1_2.getName());

      ret = client.dropType(Constants.INT_TYPE_NAME);

      assertTrue("unable to drop type integer", ret);

      boolean exceptionThrown = false;

      try {

        client.getType(Constants.INT_TYPE_NAME);

      } catch (NoSuchObjectException e) {

        exceptionThrown = true;

      }

      assertTrue("Expected NoSuchObjectException", exceptionThrown);

    } catch (Exception e) {

      System.err.println(StringUtils.stringifyException(e));

      System.err.println("testSimpleTypeApi() failed.");

      throw e;

    }

  }

  // TODO:pc need to enhance this with complex fields and getType_all function

  public void testComplexTypeApi() throws Exception {

    try {

      client.dropType("Person");

      Type typ1 = new Type();

      typ1.setName("Person");

      typ1.setFields(new ArrayList<FieldSchema>(2));

      typ1.getFields().add(

          new FieldSchema("name", Constants.STRING_TYPE_NAME, ""));

      typ1.getFields().add(

          new FieldSchema("income", Constants.INT_TYPE_NAME, ""));

      boolean ret = client.createType(typ1);

      assertTrue("Unable to create type", ret);

      Type typ1_2 = client.getType("Person");

      assertNotNull("type Person not found", typ1_2);

      assertEquals(typ1.getName(), typ1_2.getName());

      assertEquals(typ1.getFields().size(), typ1_2.getFields().size());

      assertEquals(typ1.getFields().get(0), typ1_2.getFields().get(0));

      assertEquals(typ1.getFields().get(1), typ1_2.getFields().get(1));

      client.dropType("Family");

      Type fam = new Type();

      fam.setName("Family");

      fam.setFields(new ArrayList<FieldSchema>(2));

      fam.getFields().add(

          new FieldSchema("name", Constants.STRING_TYPE_NAME, ""));

      fam.getFields().add(

          new FieldSchema("members",

              MetaStoreUtils.getListType(typ1.getName()), ""));

      ret = client.createType(fam);

      assertTrue("Unable to create type " + fam.getName(), ret);

      Type fam2 = client.getType("Family");

      assertNotNull("type Person not found", fam2);

      assertEquals(fam.getName(), fam2.getName());

      assertEquals(fam.getFields().size(), fam2.getFields().size());

      assertEquals(fam.getFields().get(0), fam2.getFields().get(0));

      assertEquals(fam.getFields().get(1), fam2.getFields().get(1));

      ret = client.dropType("Family");

      assertTrue("unable to drop type Family", ret);

      ret = client.dropType("Person");

      assertTrue("unable to drop type Person", ret);

      boolean exceptionThrown = false;

      try {

        client.getType("Person");

      } catch (NoSuchObjectException e) {