hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ga...@apache.org
Subject [01/17] hive git commit: HIVE-17990 Add Thrift and DB storage for Schema Registry objects
Date Mon, 06 Nov 2017 22:08:21 GMT
Repository: hive
Updated Branches:
  refs/heads/standalone-metastore 8af7b86e3 -> 25bc3c697


http://git-wip-us.apache.org/repos/asf/hive/blob/25bc3c69/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreSchemaMethods.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreSchemaMethods.java b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreSchemaMethods.java
new file mode 100644
index 0000000..532a65a
--- /dev/null
+++ b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestHiveMetaStoreSchemaMethods.java
@@ -0,0 +1,888 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.
+ */
+package org.apache.hadoop.hive.metastore;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
+import org.apache.hadoop.hive.metastore.api.FieldSchema;
+import org.apache.hadoop.hive.metastore.api.FindSchemasByColsResp;
+import org.apache.hadoop.hive.metastore.api.FindSchemasByColsRespEntry;
+import org.apache.hadoop.hive.metastore.api.FindSchemasByColsRqst;
+import org.apache.hadoop.hive.metastore.api.ISchema;
+import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
+import org.apache.hadoop.hive.metastore.api.MetaException;
+import org.apache.hadoop.hive.metastore.api.NoSuchObjectException;
+import org.apache.hadoop.hive.metastore.api.SchemaCompatibility;
+import org.apache.hadoop.hive.metastore.api.SchemaType;
+import org.apache.hadoop.hive.metastore.api.SchemaValidation;
+import org.apache.hadoop.hive.metastore.api.SchemaVersion;
+import org.apache.hadoop.hive.metastore.api.SchemaVersionState;
+import org.apache.hadoop.hive.metastore.api.SerDeInfo;
+import org.apache.hadoop.hive.metastore.api.SerdeType;
+import org.apache.hadoop.hive.metastore.client.builder.ISchemaBuilder;
+import org.apache.hadoop.hive.metastore.client.builder.SchemaVersionBuilder;
+import org.apache.hadoop.hive.metastore.conf.MetastoreConf;
+import org.apache.hadoop.hive.metastore.conf.MetastoreConf.ConfVars;
+import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent;
+import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent;
+import org.apache.hadoop.hive.metastore.events.AlterSchemaVersionEvent;
+import org.apache.hadoop.hive.metastore.events.CreateISchemaEvent;
+import org.apache.hadoop.hive.metastore.events.DropISchemaEvent;
+import org.apache.hadoop.hive.metastore.events.DropSchemaVersionEvent;
+import org.apache.hadoop.hive.metastore.events.PreEventContext;
+import org.apache.hadoop.hive.metastore.messaging.EventMessage;
+import org.apache.hadoop.hive.metastore.security.HadoopThriftAuthBridge;
+import org.apache.thrift.TException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+// This does the testing using a remote metastore, as that finds more issues in thrift
+public class TestHiveMetaStoreSchemaMethods {
+  private static Map<EventMessage.EventType, Integer> events;
+  private static Map<EventMessage.EventType, Integer> transactionalEvents;
+  private static Map<PreEventContext.PreEventType, Integer> preEvents;
+
+  private static IMetaStoreClient client;
+
+
+  @BeforeClass
+  public static void startMetastore() throws Exception {
+    Configuration conf = MetastoreConf.newMetastoreConf();
+    MetastoreConf.setVar(conf, ConfVars.EXPRESSION_PROXY_CLASS,
+        DefaultPartitionExpressionProxy.class.getName());
+    int port = MetaStoreTestUtils.findFreePort();
+    MetastoreConf.setVar(conf, ConfVars.THRIFT_URIS, "thrift://localhost:" + port);
+    MetastoreConf.setClass(conf, ConfVars.EVENT_LISTENERS, SchemaEventListener.class,
+        MetaStoreEventListener.class);
+    MetastoreConf.setClass(conf, ConfVars.TRANSACTIONAL_EVENT_LISTENERS, TransactionalSchemaEventListener.class,
+        MetaStoreEventListener.class);
+    MetastoreConf.setClass(conf, ConfVars.PRE_EVENT_LISTENERS, SchemaPreEventListener.class,
+        MetaStorePreEventListener.class);
+    MetaStoreTestUtils.startMetaStore(port, HadoopThriftAuthBridge.getBridge(), conf);
+
+    client = new HiveMetaStoreClient(conf);
+  }
+
+  @Before
+  public void newMaps() {
+    events = new HashMap<>();
+    transactionalEvents = new HashMap<>();
+    preEvents = new HashMap<>();
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void getNonExistentSchema() throws TException {
+    client.getISchema("no.such.schema");
+  }
+
+  @Test
+  public void iSchema() throws TException {
+    String schemaName = uniqueSchemaName();
+    String schemaGroup = "group1";
+    String description = "This is a description";
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setCompatibility(SchemaCompatibility.FORWARD)
+        .setValidationLevel(SchemaValidation.LATEST)
+        .setCanEvolve(false)
+        .setSchemaGroup(schemaGroup)
+        .setDescription(description)
+        .build();
+    client.createISchema(schema);
+
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.CREATE_ISCHEMA));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.CREATE_ISCHEMA));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.CREATE_ISCHEMA));
+
+    schema = client.getISchema(schemaName);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.READ_ISCHEMA));
+
+    Assert.assertEquals(SchemaType.AVRO, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.FORWARD, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.LATEST, schema.getValidationLevel());
+    Assert.assertFalse(schema.isCanEvolve());
+    Assert.assertEquals(schemaGroup, schema.getSchemaGroup());
+    Assert.assertEquals(description, schema.getDescription());
+
+    schemaGroup = "new group";
+    description = "new description";
+    schema.setCompatibility(SchemaCompatibility.BOTH);
+    schema.setValidationLevel(SchemaValidation.ALL);
+    schema.setCanEvolve(true);
+    schema.setSchemaGroup(schemaGroup);
+    schema.setDescription(description);
+    client.alterISchema(schemaName, schema);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.ALTER_ISCHEMA));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.ALTER_ISCHEMA));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.ALTER_ISCHEMA));
+
+    schema = client.getISchema(schemaName);
+    Assert.assertEquals(2, (int)preEvents.get(PreEventContext.PreEventType.READ_ISCHEMA));
+
+    Assert.assertEquals(SchemaType.AVRO, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.BOTH, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.ALL, schema.getValidationLevel());
+    Assert.assertTrue(schema.isCanEvolve());
+    Assert.assertEquals(schemaGroup, schema.getSchemaGroup());
+    Assert.assertEquals(description, schema.getDescription());
+
+    client.dropISchema(schemaName);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.DROP_ISCHEMA));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.DROP_ISCHEMA));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.DROP_ISCHEMA));
+    try {
+      client.getISchema(schemaName);
+      Assert.fail();
+    } catch (NoSuchObjectException e) {
+      // all good
+    }
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void schemaWithInvalidDatabase() throws TException {
+    ISchema schema = new ISchemaBuilder()
+        .setName("thisSchemaDoesntHaveADb")
+        .setDbName("no.such.database")
+        .setSchemaType(SchemaType.AVRO)
+        .build();
+    client.createISchema(schema);
+  }
+
+  @Test(expected = AlreadyExistsException.class)
+  public void schemaAlreadyExists() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.HIVE)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+
+    schema = client.getISchema(schemaName);
+    Assert.assertNotNull(schema);
+
+    Assert.assertEquals(SchemaType.HIVE, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.BACKWARD, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.ALL, schema.getValidationLevel());
+    Assert.assertTrue(schema.isCanEvolve());
+
+    // This second attempt to create it should throw
+    client.createISchema(schema);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void alterNonExistentSchema() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.HIVE)
+        .setName(schemaName)
+        .setDescription("a new description")
+        .build();
+    client.alterISchema(schemaName, schema);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void dropNonExistentSchema() throws TException {
+    client.dropISchema("no_such_schema");
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void createVersionOfNonExistentSchema() throws TException {
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName("noSchemaOfThisNameExists")
+        .setVersion(1)
+        .addCol("a", ColumnType.STRING_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+  }
+
+  @Test
+  public void addSchemaVersion() throws TException {
+    String schemaName = uniqueSchemaName();
+    int version = 1;
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+
+    String description = "very descriptive";
+    String schemaText = "this should look like json, but oh well";
+    String fingerprint = "this should be an md5 string";
+    String versionName = "why would I name a version?";
+    long creationTime = 10;
+    String serdeName = "serde_for_schema37";
+    String serializer = "org.apache.hadoop.hive.metastore.test.Serializer";
+    String deserializer = "org.apache.hadoop.hive.metastore.test.Deserializer";
+    String serdeDescription = "how do you describe a serde?";
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .setCreatedAt(creationTime)
+        .setState(SchemaVersionState.INITIATED)
+        .setDescription(description)
+        .setSchemaText(schemaText)
+        .setFingerprint(fingerprint)
+        .setName(versionName)
+        .setSerdeName(serdeName)
+        .setSerdeSerializerClass(serializer)
+        .setSerdeDeserializerClass(deserializer)
+        .setSerdeDescription(serdeDescription)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.ADD_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.ADD_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.ADD_SCHEMA_VERSION));
+
+    schemaVersion = client.getSchemaVersion(schemaName, version);
+    Assert.assertNotNull(schemaVersion);
+    Assert.assertEquals(schemaName, schemaVersion.getSchemaName());
+    Assert.assertEquals(version, schemaVersion.getVersion());
+    Assert.assertEquals(creationTime, schemaVersion.getCreatedAt());
+    Assert.assertEquals(SchemaVersionState.INITIATED, schemaVersion.getState());
+    Assert.assertEquals(description, schemaVersion.getDescription());
+    Assert.assertEquals(schemaText, schemaVersion.getSchemaText());
+    Assert.assertEquals(fingerprint, schemaVersion.getFingerprint());
+    Assert.assertEquals(versionName, schemaVersion.getName());
+    Assert.assertEquals(serdeName, schemaVersion.getSerDe().getName());
+    Assert.assertEquals(serializer, schemaVersion.getSerDe().getSerializerClass());
+    Assert.assertEquals(deserializer, schemaVersion.getSerDe().getDeserializerClass());
+    Assert.assertEquals(serdeDescription, schemaVersion.getSerDe().getDescription());
+    Assert.assertEquals(2, schemaVersion.getColsSize());
+    List<FieldSchema> cols = schemaVersion.getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals(ColumnType.INT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals(ColumnType.FLOAT_TYPE_NAME, cols.get(1).getType());
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.READ_SCHEMA_VERSION));
+
+    client.dropSchemaVersion(schemaName, version);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.DROP_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.DROP_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.DROP_SCHEMA_VERSION));
+    try {
+      client.getSchemaVersion(schemaName, version);
+      Assert.fail();
+    } catch (NoSuchObjectException e) {
+      // all good
+    }
+  }
+
+  // Test that adding multiple versions of the same schema
+  @Test
+  public void multipleSchemaVersions() throws TException {
+    String schemaName = uniqueSchemaName();
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(1)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(2)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("b", ColumnType.DATE_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(3)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("b", ColumnType.DATE_TYPE_NAME)
+        .addCol("c", ColumnType.TIMESTAMP_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+    Assert.assertEquals(3, (int)preEvents.get(PreEventContext.PreEventType.ADD_SCHEMA_VERSION));
+    Assert.assertEquals(3, (int)events.get(EventMessage.EventType.ADD_SCHEMA_VERSION));
+    Assert.assertEquals(3, (int)transactionalEvents.get(EventMessage.EventType.ADD_SCHEMA_VERSION));
+
+    schemaVersion = client.getSchemaLatestVersion(schemaName);
+    Assert.assertEquals(3, schemaVersion.getVersion());
+    Assert.assertEquals(3, schemaVersion.getColsSize());
+    List<FieldSchema> cols = schemaVersion.getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals("c", cols.get(2).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+    Assert.assertEquals(ColumnType.TIMESTAMP_TYPE_NAME, cols.get(2).getType());
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.READ_SCHEMA_VERSION));
+
+    List<SchemaVersion> versions = client.getSchemaAllVersions(schemaName);
+    Assert.assertEquals(2, (int)preEvents.get(PreEventContext.PreEventType.READ_SCHEMA_VERSION));
+    Assert.assertEquals(3, versions.size());
+    versions.sort(Comparator.comparingInt(SchemaVersion::getVersion));
+    Assert.assertEquals(1, versions.get(0).getVersion());
+    Assert.assertEquals(1, versions.get(0).getColsSize());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, versions.get(0).getCols().get(0).getType());
+
+    Assert.assertEquals(2, versions.get(1).getVersion());
+    Assert.assertEquals(2, versions.get(1).getColsSize());
+    cols = versions.get(1).getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+
+    Assert.assertEquals(3, versions.get(2).getVersion());
+    Assert.assertEquals(3, versions.get(2).getColsSize());
+    cols = versions.get(2).getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals("c", cols.get(2).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+    Assert.assertEquals(ColumnType.TIMESTAMP_TYPE_NAME, cols.get(2).getType());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void nonExistentSchemaVersion() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+    client.getSchemaVersion(schemaName, 1);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void nonExistentSchemaVersionButOtherVersionsExist() throws TException {
+    String schemaName = uniqueSchemaName();
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(1)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    client.getSchemaVersion(schemaName, 2);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void getLatestSchemaButNoVersions() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+    client.getSchemaLatestVersion(schemaName);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void getLatestSchemaNoSuchSchema() throws TException {
+    client.getSchemaLatestVersion("no.such.schema.with.this.name");
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void getAllSchemaButNoVersions() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+    client.getSchemaAllVersions(schemaName);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void getAllSchemaNoSuchSchema() throws TException {
+    client.getSchemaAllVersions("no.such.schema.with.this.name");
+  }
+
+  @Test(expected = AlreadyExistsException.class)
+  public void addDuplicateSchemaVersion() throws TException {
+    String schemaName = uniqueSchemaName();
+    int version = 1;
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    client.addSchemaVersion(schemaVersion);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void mapSerDeNoSuchSchema() throws TException {
+    SerDeInfo serDeInfo = new SerDeInfo(uniqueSerdeName(), "lib", Collections.emptyMap());
+    client.mapSchemaVersionToSerde(uniqueSchemaName(), 1, serDeInfo.getName());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void mapSerDeNoSuchSchemaVersion() throws TException {
+    SerDeInfo serDeInfo = new SerDeInfo(uniqueSerdeName(), "lib", Collections.emptyMap());
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(uniqueSchemaName())
+        .build();
+    client.createISchema(schema);
+    client.mapSchemaVersionToSerde(schema.getName(), 3, serDeInfo.getName());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void mapNonExistentSerdeToSchemaVersion() throws TException {
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(uniqueSchemaName())
+        .build();
+    client.createISchema(schema);
+
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schema.getName())
+        .setVersion(1)
+        .addCol("x", ColumnType.BOOLEAN_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+    client.mapSchemaVersionToSerde(schema.getName(), schemaVersion.getVersion(), uniqueSerdeName());
+  }
+
+  @Test
+  public void mapSerdeToSchemaVersion() throws TException {
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(uniqueSchemaName())
+        .build();
+    client.createISchema(schema);
+
+    // Create schema with no serde, then map it
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schema.getName())
+        .setVersion(1)
+        .addCol("x", ColumnType.BOOLEAN_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    SerDeInfo serDeInfo = new SerDeInfo(uniqueSerdeName(), "lib", Collections.emptyMap());
+    client.addSerDe(serDeInfo);
+
+    client.mapSchemaVersionToSerde(schema.getName(), schemaVersion.getVersion(), serDeInfo.getName());
+    schemaVersion = client.getSchemaVersion(schema.getName(), schemaVersion.getVersion());
+    Assert.assertEquals(serDeInfo.getName(), schemaVersion.getSerDe().getName());
+
+    // Create schema with a serde, then remap it
+    String serDeName = uniqueSerdeName();
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schema.getName())
+        .setVersion(2)
+        .addCol("x", ColumnType.BOOLEAN_TYPE_NAME)
+        .setSerdeName(serDeName)
+        .setSerdeLib("x")
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    schemaVersion = client.getSchemaVersion(schema.getName(), 2);
+    Assert.assertEquals(serDeName, schemaVersion.getSerDe().getName());
+
+    serDeInfo = new SerDeInfo(uniqueSerdeName(), "y", Collections.emptyMap());
+    client.addSerDe(serDeInfo);
+    client.mapSchemaVersionToSerde(schema.getName(), 2, serDeInfo.getName());
+    schemaVersion = client.getSchemaVersion(schema.getName(), 2);
+    Assert.assertEquals(serDeInfo.getName(), schemaVersion.getSerDe().getName());
+
+  }
+
+  @Test
+  public void addSerde() throws TException {
+    String serdeName = uniqueSerdeName();
+    SerDeInfo serDeInfo = new SerDeInfo(serdeName, "serdeLib", Collections.singletonMap("a", "b"));
+    serDeInfo.setSerializerClass("serializer");
+    serDeInfo.setDeserializerClass("deserializer");
+    serDeInfo.setDescription("description");
+    serDeInfo.setSerdeType(SerdeType.SCHEMA_REGISTRY);
+    client.addSerDe(serDeInfo);
+
+    serDeInfo = client.getSerDe(serdeName);
+    Assert.assertEquals(serdeName, serDeInfo.getName());
+    Assert.assertEquals("serdeLib", serDeInfo.getSerializationLib());
+    Assert.assertEquals(1, serDeInfo.getParametersSize());
+    Assert.assertEquals("b", serDeInfo.getParameters().get("a"));
+    Assert.assertEquals("serializer", serDeInfo.getSerializerClass());
+    Assert.assertEquals("deserializer", serDeInfo.getDeserializerClass());
+    Assert.assertEquals("description", serDeInfo.getDescription());
+    Assert.assertEquals(SerdeType.SCHEMA_REGISTRY, serDeInfo.getSerdeType());
+  }
+
+  @Test(expected = AlreadyExistsException.class)
+  public void duplicateSerde() throws TException {
+    String serdeName = uniqueSerdeName();
+    SerDeInfo serDeInfo = new SerDeInfo(serdeName, "x", Collections.emptyMap());
+    client.addSerDe(serDeInfo);
+    client.addSerDe(serDeInfo);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void noSuchSerDe() throws TException {
+    client.getSerDe(uniqueSerdeName());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void setVersionStateNoSuchSchema() throws TException {
+    client.setSchemaVersionState("no.such.schema", 1, SchemaVersionState.INITIATED);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void setVersionStateNoSuchVersion() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+    client.setSchemaVersionState(schemaName, 1, SchemaVersionState.INITIATED);
+  }
+
+  @Test
+  public void setVersionState() throws TException {
+    String schemaName = uniqueSchemaName();
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .build();
+    client.createISchema(schema);
+
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(1)
+        .addCol("a", ColumnType.BINARY_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion);
+
+    schemaVersion = client.getSchemaVersion(schemaName, 1);
+    Assert.assertNull(schemaVersion.getState());
+
+    client.setSchemaVersionState(schemaName, 1, SchemaVersionState.INITIATED);
+    Assert.assertEquals(1, (int)preEvents.get(PreEventContext.PreEventType.ALTER_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)events.get(EventMessage.EventType.ALTER_SCHEMA_VERSION));
+    Assert.assertEquals(1, (int)transactionalEvents.get(EventMessage.EventType.ALTER_SCHEMA_VERSION));
+    schemaVersion = client.getSchemaVersion(schemaName, 1);
+    Assert.assertEquals(SchemaVersionState.INITIATED, schemaVersion.getState());
+
+    client.setSchemaVersionState(schemaName, 1, SchemaVersionState.REVIEWED);
+    Assert.assertEquals(2, (int)preEvents.get(PreEventContext.PreEventType.ALTER_SCHEMA_VERSION));
+    Assert.assertEquals(2, (int)events.get(EventMessage.EventType.ALTER_SCHEMA_VERSION));
+    Assert.assertEquals(2, (int)transactionalEvents.get(EventMessage.EventType.ALTER_SCHEMA_VERSION));
+    schemaVersion = client.getSchemaVersion(schemaName, 1);
+    Assert.assertEquals(SchemaVersionState.REVIEWED, schemaVersion.getState());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void dropNonExistentSchemaVersion() throws TException {
+    client.dropSchemaVersion("ther is no schema named this", 23);
+  }
+
+  @Test
+  public void schemaQuery() throws TException {
+    String schemaName1 = uniqueSchemaName();
+    ISchema schema1 = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName1)
+        .build();
+    client.createISchema(schema1);
+
+    String schemaName2 = uniqueSchemaName();
+    ISchema schema2 = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName2)
+        .build();
+    client.createISchema(schema2);
+
+    SchemaVersion schemaVersion1_1 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName1)
+        .setVersion(1)
+        .addCol("alpha", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("beta", ColumnType.DATE_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion1_1);
+
+    SchemaVersion schemaVersion1_2 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName1)
+        .setVersion(2)
+        .addCol("alpha", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("beta", ColumnType.DATE_TYPE_NAME)
+        .addCol("gamma", ColumnType.BIGINT_TYPE_NAME, "namespace=x")
+        .build();
+    client.addSchemaVersion(schemaVersion1_2);
+
+    SchemaVersion schemaVersion2_1 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName2)
+        .setVersion(1)
+        .addCol("ALPHA", ColumnType.SMALLINT_TYPE_NAME)
+        .addCol("delta", ColumnType.DOUBLE_TYPE_NAME)
+        .build();
+    client.addSchemaVersion(schemaVersion2_1);
+
+    SchemaVersion schemaVersion2_2 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName2)
+        .setVersion(2)
+        .addCol("ALPHA", ColumnType.SMALLINT_TYPE_NAME)
+        .addCol("delta", ColumnType.DOUBLE_TYPE_NAME)
+        .addCol("epsilon", ColumnType.STRING_TYPE_NAME, "namespace=x")
+        .build();
+    client.addSchemaVersion(schemaVersion2_2);
+
+    // Query that should return nothing
+    FindSchemasByColsRqst rqst = new FindSchemasByColsRqst();
+    rqst.setColName("x");
+    rqst.setColNamespace("y");
+    rqst.setType("z");
+    FindSchemasByColsResp rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(0, rsp.getSchemaVersionsSize());
+
+    // Query that should fetch one column
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColName("gamma");
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(1, rsp.getSchemaVersionsSize());
+    Assert.assertEquals(schemaName1, rsp.getSchemaVersions().get(0).getSchemaName());
+    Assert.assertEquals(2, rsp.getSchemaVersions().get(0).getVersion());
+
+    // fetch 2 in same schema
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColName("beta");
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(2, rsp.getSchemaVersionsSize());
+    List<FindSchemasByColsRespEntry> results = new ArrayList<>(rsp.getSchemaVersions());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName1, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // fetch across schemas
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColName("alpha");
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(4, rsp.getSchemaVersionsSize());
+    results = new ArrayList<>(rsp.getSchemaVersions());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName1, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+    Assert.assertEquals(schemaName2, results.get(2).getSchemaName());
+    Assert.assertEquals(1, results.get(2).getVersion());
+    Assert.assertEquals(schemaName2, results.get(3).getSchemaName());
+    Assert.assertEquals(2, results.get(3).getVersion());
+
+    // fetch by namespace
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColNamespace("namespace=x");
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(2, rsp.getSchemaVersionsSize());
+    results = new ArrayList<>(rsp.getSchemaVersions());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(2, results.get(0).getVersion());
+    Assert.assertEquals(schemaName2, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // fetch by name and type
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColName("alpha");
+    rqst.setType(ColumnType.SMALLINT_TYPE_NAME);
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(2, rsp.getSchemaVersionsSize());
+    results = new ArrayList<>(rsp.getSchemaVersions());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName2, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName2, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // Make sure matching name but wrong type doesn't return
+    rqst = new FindSchemasByColsRqst();
+    rqst.setColName("alpha");
+    rqst.setType(ColumnType.STRING_TYPE_NAME);
+    rsp = client.getSchemaByCols(rqst);
+    Assert.assertEquals(0, rsp.getSchemaVersionsSize());
+  }
+
+  @Test(expected = MetaException.class)
+  public void schemaVersionQueryNoNameOrNamespace() throws TException {
+    FindSchemasByColsRqst rqst = new FindSchemasByColsRqst();
+    rqst.setType(ColumnType.STRING_TYPE_NAME);
+    client.getSchemaByCols(rqst);
+  }
+
+  private static int nextSchemaNum = 1;
+
+  private String uniqueSchemaName() {
+    return "uniqueschema" + nextSchemaNum++;
+
+  }
+
+  private String uniqueSerdeName() {
+    return "uniqueSerde" + nextSchemaNum++;
+  }
+
+  public static class SchemaEventListener extends MetaStoreEventListener {
+
+    public SchemaEventListener(Configuration config) {
+      super(config);
+    }
+
+    @Override
+    public void onCreateISchema(CreateISchemaEvent createISchemaEvent) throws MetaException {
+      Integer cnt = events.get(EventMessage.EventType.CREATE_ISCHEMA);
+      events.put(EventMessage.EventType.CREATE_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAlterISchema(AlterISchemaEvent alterISchemaEvent) throws MetaException {
+      Integer cnt = events.get(EventMessage.EventType.ALTER_ISCHEMA);
+      events.put(EventMessage.EventType.ALTER_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onDropISchema(DropISchemaEvent dropISchemaEvent) throws MetaException {
+      Integer cnt = events.get(EventMessage.EventType.DROP_ISCHEMA);
+      events.put(EventMessage.EventType.DROP_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAddSchemaVersion(AddSchemaVersionEvent addSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = events.get(EventMessage.EventType.ADD_SCHEMA_VERSION);
+      events.put(EventMessage.EventType.ADD_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAlterSchemaVersion(AlterSchemaVersionEvent alterSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = events.get(EventMessage.EventType.ALTER_SCHEMA_VERSION);
+      events.put(EventMessage.EventType.ALTER_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onDropSchemaVersion(DropSchemaVersionEvent dropSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = events.get(EventMessage.EventType.DROP_SCHEMA_VERSION);
+      events.put(EventMessage.EventType.DROP_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+  }
+
+  public static class TransactionalSchemaEventListener extends MetaStoreEventListener {
+
+    public TransactionalSchemaEventListener(Configuration config) {
+      super(config);
+    }
+
+    @Override
+    public void onCreateISchema(CreateISchemaEvent createISchemaEvent) throws MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.CREATE_ISCHEMA);
+      transactionalEvents.put(EventMessage.EventType.CREATE_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAlterISchema(AlterISchemaEvent alterISchemaEvent) throws MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.ALTER_ISCHEMA);
+      transactionalEvents.put(EventMessage.EventType.ALTER_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onDropISchema(DropISchemaEvent dropISchemaEvent) throws MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.DROP_ISCHEMA);
+      transactionalEvents.put(EventMessage.EventType.DROP_ISCHEMA, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAddSchemaVersion(AddSchemaVersionEvent addSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.ADD_SCHEMA_VERSION);
+      transactionalEvents.put(EventMessage.EventType.ADD_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onAlterSchemaVersion(AlterSchemaVersionEvent alterSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.ALTER_SCHEMA_VERSION);
+      transactionalEvents.put(EventMessage.EventType.ALTER_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+
+    @Override
+    public void onDropSchemaVersion(DropSchemaVersionEvent dropSchemaVersionEvent) throws
+        MetaException {
+      Integer cnt = transactionalEvents.get(EventMessage.EventType.DROP_SCHEMA_VERSION);
+      transactionalEvents.put(EventMessage.EventType.DROP_SCHEMA_VERSION, cnt == null ? 1 : cnt + 1);
+    }
+  }
+
+  public static class SchemaPreEventListener extends MetaStorePreEventListener {
+
+    public SchemaPreEventListener(Configuration config) {
+      super(config);
+    }
+
+    @Override
+    public void onEvent(PreEventContext context) throws MetaException, NoSuchObjectException,
+        InvalidOperationException {
+      Integer cnt = preEvents.get(context.getEventType());
+      preEvents.put(context.getEventType(), cnt == null ? 1 : cnt + 1);
+
+    }
+  }
+
+
+}

http://git-wip-us.apache.org/repos/asf/hive/blob/25bc3c69/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStore.java b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStore.java
index 6a39538..891db29 100644
--- a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStore.java
+++ b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStore.java
@@ -26,7 +26,6 @@ import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.hive.metastore.api.CurrentNotificationEventId;
 import org.apache.hadoop.hive.metastore.api.Database;
 import org.apache.hadoop.hive.metastore.api.FieldSchema;
-import org.apache.hadoop.hive.metastore.api.FileMetadataExprType;
 import org.apache.hadoop.hive.metastore.api.Function;
 import org.apache.hadoop.hive.metastore.api.Index;
 import org.apache.hadoop.hive.metastore.api.InvalidInputException;
@@ -50,7 +49,6 @@ import org.apache.hadoop.hive.metastore.metrics.Metrics;
 import org.apache.hadoop.hive.metastore.metrics.MetricsConstants;
 import org.apache.hadoop.hive.metastore.model.MNotificationLog;
 import org.apache.hadoop.hive.metastore.model.MNotificationNextId;
-import org.apache.hadoop.hive.ql.io.sarg.SearchArgument;
 import org.junit.Assert;
 import org.junit.Assume;
 import org.junit.Before;
@@ -96,41 +94,11 @@ public class TestObjectStore {
     }
   }
 
-  public static class MockPartitionExpressionProxy implements PartitionExpressionProxy {
-    @Override
-    public String convertExprToFilter(byte[] expr) throws MetaException {
-      return null;
-    }
-
-    @Override
-    public boolean filterPartitionsByExpr(List<FieldSchema> partColumns,
-                                          byte[] expr, String defaultPartitionName,
-                                          List<String> partitionNames)
-        throws MetaException {
-      return false;
-    }
-
-    @Override
-    public FileMetadataExprType getMetadataType(String inputFormat) {
-      return null;
-    }
-
-    @Override
-    public SearchArgument createSarg(byte[] expr) {
-      return null;
-    }
-
-    @Override
-    public FileFormatProxy getFileFormatProxy(FileMetadataExprType type) {
-      return null;
-    }
-  }
-
   @Before
   public void setUp() throws Exception {
     Configuration conf = MetastoreConf.newMetastoreConf();
     MetastoreConf.setVar(conf, MetastoreConf.ConfVars.EXPRESSION_PROXY_CLASS,
-        MockPartitionExpressionProxy.class.getName());
+        DefaultPartitionExpressionProxy.class.getName());
 
     objectStore = new ObjectStore();
     objectStore.setConf(conf);
@@ -463,7 +431,7 @@ public class TestObjectStore {
     Assume.assumeTrue(System.getProperty(key) == null);
     Configuration localConf = MetastoreConf.newMetastoreConf();
     MetastoreConf.setVar(localConf, MetastoreConf.ConfVars.EXPRESSION_PROXY_CLASS,
-        MockPartitionExpressionProxy.class.getName());
+        DefaultPartitionExpressionProxy.class.getName());
     localConf.set(key, value);
     localConf.set(key1, value1);
     objectStore = new ObjectStore();
@@ -538,7 +506,7 @@ public class TestObjectStore {
 
     Configuration conf = MetastoreConf.newMetastoreConf();
     MetastoreConf.setVar(conf, MetastoreConf.ConfVars.EXPRESSION_PROXY_CLASS,
-        MockPartitionExpressionProxy.class.getName());
+        DefaultPartitionExpressionProxy.class.getName());
     /*
        Below are the properties that need to be set based on what database this test is going to be run
      */

http://git-wip-us.apache.org/repos/asf/hive/blob/25bc3c69/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStoreSchemaMethods.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStoreSchemaMethods.java b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStoreSchemaMethods.java
new file mode 100644
index 0000000..ffe0e54
--- /dev/null
+++ b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/TestObjectStoreSchemaMethods.java
@@ -0,0 +1,550 @@
+/*
+ * 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
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * 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.
+ */
+package org.apache.hadoop.hive.metastore;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hive.metastore.api.AlreadyExistsException;
+import org.apache.hadoop.hive.metastore.api.Database;
+import org.apache.hadoop.hive.metastore.api.FieldSchema;
+import org.apache.hadoop.hive.metastore.api.ISchema;
+import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
+import org.apache.hadoop.hive.metastore.api.MetaException;
+import org.apache.hadoop.hive.metastore.api.NoSuchObjectException;
+import org.apache.hadoop.hive.metastore.api.SchemaCompatibility;
+import org.apache.hadoop.hive.metastore.api.SchemaType;
+import org.apache.hadoop.hive.metastore.api.SchemaValidation;
+import org.apache.hadoop.hive.metastore.api.SchemaVersion;
+import org.apache.hadoop.hive.metastore.api.SchemaVersionState;
+import org.apache.hadoop.hive.metastore.api.SerDeInfo;
+import org.apache.hadoop.hive.metastore.client.builder.DatabaseBuilder;
+import org.apache.hadoop.hive.metastore.client.builder.ISchemaBuilder;
+import org.apache.hadoop.hive.metastore.client.builder.SchemaVersionBuilder;
+import org.apache.hadoop.hive.metastore.conf.MetastoreConf;
+import org.apache.thrift.TException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class TestObjectStoreSchemaMethods {
+  private ObjectStore objectStore;
+
+  @Before
+  public void setUp() throws Exception {
+    Configuration conf = MetastoreConf.newMetastoreConf();
+    MetastoreConf.setVar(conf, MetastoreConf.ConfVars.EXPRESSION_PROXY_CLASS,
+        DefaultPartitionExpressionProxy.class.getName());
+
+    objectStore = new ObjectStore();
+    objectStore.setConf(conf);
+  }
+
+  @Test
+  public void iSchema() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    ISchema schema = objectStore.getISchema("no.such.schema");
+    Assert.assertNull(schema);
+
+    String schemaName = "schema1";
+    String schemaGroup = "group1";
+    String description = "This is a description";
+    schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .setCompatibility(SchemaCompatibility.FORWARD)
+        .setValidationLevel(SchemaValidation.LATEST)
+        .setCanEvolve(false)
+        .setSchemaGroup(schemaGroup)
+        .setDescription(description)
+        .build();
+    objectStore.createISchema(schema);
+
+    schema = objectStore.getISchema(schemaName);
+    Assert.assertNotNull(schema);
+
+    Assert.assertEquals(SchemaType.AVRO, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.FORWARD, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.LATEST, schema.getValidationLevel());
+    Assert.assertFalse(schema.isCanEvolve());
+    Assert.assertEquals(schemaGroup, schema.getSchemaGroup());
+    Assert.assertEquals(description, schema.getDescription());
+
+    schemaGroup = "new group";
+    description = "new description";
+    schema.setCompatibility(SchemaCompatibility.BOTH);
+    schema.setValidationLevel(SchemaValidation.ALL);
+    schema.setCanEvolve(true);
+    schema.setSchemaGroup(schemaGroup);
+    schema.setDescription(description);
+    objectStore.alterISchema(schemaName, schema);
+
+    schema = objectStore.getISchema(schemaName);
+    Assert.assertNotNull(schema);
+
+    Assert.assertEquals(SchemaType.AVRO, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.BOTH, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.ALL, schema.getValidationLevel());
+    Assert.assertTrue(schema.isCanEvolve());
+    Assert.assertEquals(schemaGroup, schema.getSchemaGroup());
+    Assert.assertEquals(description, schema.getDescription());
+
+    objectStore.dropISchema(schemaName);
+    schema = objectStore.getISchema(schemaName);
+    Assert.assertNull(schema);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void schemaWithInvalidDatabase() throws MetaException, AlreadyExistsException,
+      NoSuchObjectException {
+    ISchema schema = new ISchemaBuilder()
+        .setName("thisSchemaDoesntHaveADb")
+        .setDbName("no.such.database")
+        .setSchemaType(SchemaType.AVRO)
+        .build();
+    objectStore.createISchema(schema);
+  }
+
+  @Test(expected = AlreadyExistsException.class)
+  public void schemaAlreadyExists() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName = "schema2";
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.HIVE)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema);
+
+    schema = objectStore.getISchema(schemaName);
+    Assert.assertNotNull(schema);
+
+    Assert.assertEquals(SchemaType.HIVE, schema.getSchemaType());
+    Assert.assertEquals(schemaName, schema.getName());
+    Assert.assertEquals(SchemaCompatibility.BACKWARD, schema.getCompatibility());
+    Assert.assertEquals(SchemaValidation.ALL, schema.getValidationLevel());
+    Assert.assertTrue(schema.isCanEvolve());
+
+    // This second attempt to create it should throw
+    objectStore.createISchema(schema);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void alterNonExistentSchema() throws MetaException, NoSuchObjectException {
+    String schemaName = "noSuchSchema";
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.HIVE)
+        .setName(schemaName)
+        .setDescription("a new description")
+        .build();
+    objectStore.alterISchema(schemaName, schema);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void dropNonExistentSchema() throws MetaException, NoSuchObjectException {
+    objectStore.dropISchema("no_such_schema");
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void createVersionOfNonExistentSchema() throws MetaException, AlreadyExistsException,
+      NoSuchObjectException {
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName("noSchemaOfThisNameExists")
+        .setVersion(1)
+        .addCol("a", ColumnType.STRING_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+  }
+
+  @Test
+  public void addSchemaVersion() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName = "schema37";
+    int version = 1;
+    SchemaVersion schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNull(schemaVersion);
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema);
+
+    String description = "very descriptive";
+    String schemaText = "this should look like json, but oh well";
+    String fingerprint = "this should be an md5 string";
+    String versionName = "why would I name a version?";
+    long creationTime = 10;
+    String serdeName = "serde_for_schema37";
+    String serializer = "org.apache.hadoop.hive.metastore.test.Serializer";
+    String deserializer = "org.apache.hadoop.hive.metastore.test.Deserializer";
+    String serdeDescription = "how do you describe a serde?";
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .setCreatedAt(creationTime)
+        .setState(SchemaVersionState.INITIATED)
+        .setDescription(description)
+        .setSchemaText(schemaText)
+        .setFingerprint(fingerprint)
+        .setName(versionName)
+        .setSerdeName(serdeName)
+        .setSerdeSerializerClass(serializer)
+        .setSerdeDeserializerClass(deserializer)
+        .setSerdeDescription(serdeDescription)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNotNull(schemaVersion);
+    Assert.assertEquals(schemaName, schemaVersion.getSchemaName());
+    Assert.assertEquals(version, schemaVersion.getVersion());
+    Assert.assertEquals(creationTime, schemaVersion.getCreatedAt());
+    Assert.assertEquals(SchemaVersionState.INITIATED, schemaVersion.getState());
+    Assert.assertEquals(description, schemaVersion.getDescription());
+    Assert.assertEquals(schemaText, schemaVersion.getSchemaText());
+    Assert.assertEquals(fingerprint, schemaVersion.getFingerprint());
+    Assert.assertEquals(versionName, schemaVersion.getName());
+    Assert.assertEquals(serdeName, schemaVersion.getSerDe().getName());
+    Assert.assertEquals(serializer, schemaVersion.getSerDe().getSerializerClass());
+    Assert.assertEquals(deserializer, schemaVersion.getSerDe().getDeserializerClass());
+    Assert.assertEquals(serdeDescription, schemaVersion.getSerDe().getDescription());
+    Assert.assertEquals(2, schemaVersion.getColsSize());
+    List<FieldSchema> cols = schemaVersion.getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals(ColumnType.INT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals(ColumnType.FLOAT_TYPE_NAME, cols.get(1).getType());
+
+    objectStore.dropSchemaVersion(schemaName, version);
+    schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNull(schemaVersion);
+  }
+
+  // Test that adding multiple versions of the same schema
+  @Test
+  public void multipleSchemaVersions() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName = "schema195";
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema);
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(1)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(2)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("b", ColumnType.DATE_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(3)
+        .addCol("a", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("b", ColumnType.DATE_TYPE_NAME)
+        .addCol("c", ColumnType.TIMESTAMP_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    schemaVersion = objectStore.getLatestSchemaVersion(schemaName);
+    Assert.assertEquals(3, schemaVersion.getVersion());
+    Assert.assertEquals(3, schemaVersion.getColsSize());
+    List<FieldSchema> cols = schemaVersion.getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals("c", cols.get(2).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+    Assert.assertEquals(ColumnType.TIMESTAMP_TYPE_NAME, cols.get(2).getType());
+
+    schemaVersion = objectStore.getLatestSchemaVersion("no.such.schema.with.this.name");
+    Assert.assertNull(schemaVersion);
+
+    List<SchemaVersion> versions =
+        objectStore.getAllSchemaVersion("there.really.isnt.a.schema.named.this");
+    Assert.assertNull(versions);
+
+    versions = objectStore.getAllSchemaVersion(schemaName);
+    Assert.assertEquals(3, versions.size());
+    versions.sort(Comparator.comparingInt(SchemaVersion::getVersion));
+    Assert.assertEquals(1, versions.get(0).getVersion());
+    Assert.assertEquals(1, versions.get(0).getColsSize());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, versions.get(0).getCols().get(0).getType());
+
+    Assert.assertEquals(2, versions.get(1).getVersion());
+    Assert.assertEquals(2, versions.get(1).getColsSize());
+    cols = versions.get(1).getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+
+    Assert.assertEquals(3, versions.get(2).getVersion());
+    Assert.assertEquals(3, versions.get(2).getColsSize());
+    cols = versions.get(2).getCols();
+    Collections.sort(cols);
+    Assert.assertEquals("a", cols.get(0).getName());
+    Assert.assertEquals("b", cols.get(1).getName());
+    Assert.assertEquals("c", cols.get(2).getName());
+    Assert.assertEquals(ColumnType.BIGINT_TYPE_NAME, cols.get(0).getType());
+    Assert.assertEquals(ColumnType.DATE_TYPE_NAME, cols.get(1).getType());
+    Assert.assertEquals(ColumnType.TIMESTAMP_TYPE_NAME, cols.get(2).getType());
+  }
+
+  @Test(expected = AlreadyExistsException.class)
+  public void addDuplicateSchemaVersion() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName = "schema1234";
+    int version = 1;
+    SchemaVersion schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNull(schemaVersion);
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    objectStore.addSchemaVersion(schemaVersion);
+  }
+
+  @Test
+  public void alterSchemaVersion() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName = "schema371234";
+    int version = 1;
+    SchemaVersion schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNull(schemaVersion);
+
+    ISchema schema = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema);
+
+    schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .setState(SchemaVersionState.INITIATED)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion);
+
+    schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNotNull(schemaVersion);
+    Assert.assertEquals(schemaName, schemaVersion.getSchemaName());
+    Assert.assertEquals(version, schemaVersion.getVersion());
+    Assert.assertEquals(SchemaVersionState.INITIATED, schemaVersion.getState());
+
+    schemaVersion.setState(SchemaVersionState.REVIEWED);
+    String serdeName = "serde for " + schemaName;
+    SerDeInfo serde = new SerDeInfo(serdeName, "", Collections.emptyMap());
+    String serializer = "org.apache.hadoop.hive.metastore.test.Serializer";
+    String deserializer = "org.apache.hadoop.hive.metastore.test.Deserializer";
+    serde.setSerializerClass(serializer);
+    serde.setDeserializerClass(deserializer);
+    schemaVersion.setSerDe(serde);
+    objectStore.alterSchemaVersion(schemaName, version, schemaVersion);
+
+    schemaVersion = objectStore.getSchemaVersion(schemaName, version);
+    Assert.assertNotNull(schemaVersion);
+    Assert.assertEquals(schemaName, schemaVersion.getSchemaName());
+    Assert.assertEquals(version, schemaVersion.getVersion());
+    Assert.assertEquals(SchemaVersionState.REVIEWED, schemaVersion.getState());
+    Assert.assertEquals(serdeName, schemaVersion.getSerDe().getName());
+    Assert.assertEquals(serializer, schemaVersion.getSerDe().getSerializerClass());
+    Assert.assertEquals(deserializer, schemaVersion.getSerDe().getDeserializerClass());
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void alterNonExistentSchemaVersion() throws MetaException, AlreadyExistsException,
+      NoSuchObjectException {
+    String schemaName = "schema3723asdflj";
+    int version = 37;
+    SchemaVersion schemaVersion = new SchemaVersionBuilder()
+        .setSchemaName(schemaName)
+        .setVersion(version)
+        .addCol("a", ColumnType.INT_TYPE_NAME)
+        .addCol("b", ColumnType.FLOAT_TYPE_NAME)
+        .setState(SchemaVersionState.INITIATED)
+        .build();
+    objectStore.alterSchemaVersion(schemaName, version, schemaVersion);
+  }
+
+  @Test(expected = NoSuchObjectException.class)
+  public void dropNonExistentSchemaVersion() throws NoSuchObjectException, MetaException {
+    objectStore.dropSchemaVersion("ther is no schema named this", 23);
+  }
+
+  @Test
+  public void schemaQuery() throws TException {
+    String dbName = createUniqueDatabaseForTest();
+    String schemaName1 = "a_schema1";
+    ISchema schema1 = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName1)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema1);
+
+    String schemaName2 = "a_schema2";
+    ISchema schema2 = new ISchemaBuilder()
+        .setSchemaType(SchemaType.AVRO)
+        .setName(schemaName2)
+        .setDbName(dbName)
+        .build();
+    objectStore.createISchema(schema2);
+
+    SchemaVersion schemaVersion1_1 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName1)
+        .setVersion(1)
+        .addCol("alpha", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("beta", ColumnType.DATE_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion1_1);
+
+    SchemaVersion schemaVersion1_2 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName1)
+        .setVersion(2)
+        .addCol("alpha", ColumnType.BIGINT_TYPE_NAME)
+        .addCol("beta", ColumnType.DATE_TYPE_NAME)
+        .addCol("gamma", ColumnType.BIGINT_TYPE_NAME, "namespace=x")
+        .build();
+    objectStore.addSchemaVersion(schemaVersion1_2);
+
+    SchemaVersion schemaVersion2_1 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName2)
+        .setVersion(1)
+        .addCol("ALPHA", ColumnType.SMALLINT_TYPE_NAME)
+        .addCol("delta", ColumnType.DOUBLE_TYPE_NAME)
+        .build();
+    objectStore.addSchemaVersion(schemaVersion2_1);
+
+    SchemaVersion schemaVersion2_2 = new SchemaVersionBuilder()
+        .setSchemaName(schemaName2)
+        .setVersion(2)
+        .addCol("ALPHA", ColumnType.SMALLINT_TYPE_NAME)
+        .addCol("delta", ColumnType.DOUBLE_TYPE_NAME)
+        .addCol("epsilon", ColumnType.STRING_TYPE_NAME, "namespace=x")
+        .build();
+    objectStore.addSchemaVersion(schemaVersion2_2);
+
+    // Query that should return nothing
+    List<SchemaVersion> results = objectStore.getSchemaVersionsByColumns("x", "y", "z");
+    Assert.assertEquals(0, results.size());
+
+    // Query that should fetch one column
+    results = objectStore.getSchemaVersionsByColumns("gamma", null, null);
+    Assert.assertEquals(1, results.size());
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(2, results.get(0).getVersion());
+
+    // fetch 2 in same schema
+    results = objectStore.getSchemaVersionsByColumns("beta", null, null);
+    Assert.assertEquals(2, results.size());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName1, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // fetch across schemas
+    results = objectStore.getSchemaVersionsByColumns("alpha", null, null);
+    Assert.assertEquals(4, results.size());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName1, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+    Assert.assertEquals(schemaName2, results.get(2).getSchemaName());
+    Assert.assertEquals(1, results.get(2).getVersion());
+    Assert.assertEquals(schemaName2, results.get(3).getSchemaName());
+    Assert.assertEquals(2, results.get(3).getVersion());
+
+    // fetch by namespace
+    results = objectStore.getSchemaVersionsByColumns(null, "namespace=x", null);
+    Assert.assertEquals(2, results.size());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName1, results.get(0).getSchemaName());
+    Assert.assertEquals(2, results.get(0).getVersion());
+    Assert.assertEquals(schemaName2, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // fetch by name and type
+    results = objectStore.getSchemaVersionsByColumns("alpha", null, ColumnType.SMALLINT_TYPE_NAME);
+    Assert.assertEquals(2, results.size());
+    Collections.sort(results);
+    Assert.assertEquals(schemaName2, results.get(0).getSchemaName());
+    Assert.assertEquals(1, results.get(0).getVersion());
+    Assert.assertEquals(schemaName2, results.get(1).getSchemaName());
+    Assert.assertEquals(2, results.get(1).getVersion());
+
+    // Make sure matching name but wrong type doesn't return
+    results = objectStore.getSchemaVersionsByColumns("alpha", null, ColumnType.STRING_TYPE_NAME); Assert.assertEquals(0, results.size());
+  }
+
+  @Test(expected = MetaException.class)
+  public void schemaVersionQueryNoNameOrNamespace() throws MetaException {
+    objectStore.getSchemaVersionsByColumns(null, null, ColumnType.STRING_TYPE_NAME);
+  }
+
+  private static int dbNum = 1;
+  private String createUniqueDatabaseForTest() throws MetaException, InvalidObjectException {
+    String dbName = "uniquedbfortest" + dbNum++;
+    Database db = new DatabaseBuilder()
+        .setName(dbName)
+        .setLocation("somewhere")
+        .setDescription("descriptive")
+        .build();
+    objectStore.createDatabase(db);
+    return dbName;
+  }
+}

http://git-wip-us.apache.org/repos/asf/hive/blob/25bc3c69/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/cache/TestCachedStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/cache/TestCachedStore.java b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/cache/TestCachedStore.java
index d486f7c..28858def 100644
--- a/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/cache/TestCachedStore.java
+++ b/standalone-metastore/src/test/java/org/apache/hadoop/hive/metastore/cache/TestCachedStore.java
@@ -25,9 +25,9 @@ import java.util.Map;
 
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.hive.common.ndv.hll.HyperLogLog;
+import org.apache.hadoop.hive.metastore.DefaultPartitionExpressionProxy;
 import org.apache.hadoop.hive.metastore.ObjectStore;
 import org.apache.hadoop.hive.metastore.TableType;
-import org.apache.hadoop.hive.metastore.TestObjectStore.MockPartitionExpressionProxy;
 import org.apache.hadoop.hive.metastore.api.AggrStats;
 import org.apache.hadoop.hive.metastore.api.BooleanColumnStatsData;
 import org.apache.hadoop.hive.metastore.api.ColumnStatistics;
@@ -60,7 +60,7 @@ public class TestCachedStore {
     Configuration conf = MetastoreConf.newMetastoreConf();
     MetastoreConf.setBoolVar(conf, MetastoreConf.ConfVars.HIVE_IN_TEST, true);
     MetastoreConf.setVar(conf, MetastoreConf.ConfVars.EXPRESSION_PROXY_CLASS,
-        MockPartitionExpressionProxy.class.getName());
+        DefaultPartitionExpressionProxy.class.getName());
     objectStore = new ObjectStore();
     objectStore.setConf(conf);
     cachedStore = new CachedStore();


Mime
View raw message