You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ga...@apache.org on 2018/03/12 23:55:44 UTC
[04/18] hive git commit: HIVE-17990 Add Thrift and DB storage for
Schema Registry objects (Alan Gates, reviewed by Thejas Nair)
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
index c99c3af..db09407 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
@@ -53,6 +53,7 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
import java.util.regex.Pattern;
import javax.jdo.JDOException;
@@ -79,33 +80,47 @@ import org.apache.hadoop.hive.metastore.events.AddPartitionEvent;
import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent;
import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent;
import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent;
import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.AlterSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.AlterTableEvent;
import org.apache.hadoop.hive.metastore.events.ConfigChangeEvent;
import org.apache.hadoop.hive.metastore.events.CreateDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.CreateFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.CreateISchemaEvent;
+import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.CreateTableEvent;
import org.apache.hadoop.hive.metastore.events.DropConstraintEvent;
import org.apache.hadoop.hive.metastore.events.DropDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.DropFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.DropISchemaEvent;
import org.apache.hadoop.hive.metastore.events.DropPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.DropSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.DropTableEvent;
import org.apache.hadoop.hive.metastore.events.InsertEvent;
import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent;
import org.apache.hadoop.hive.metastore.events.PreAddPartitionEvent;
import org.apache.hadoop.hive.metastore.events.PreAlterDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.PreAlterISchemaEvent;
import org.apache.hadoop.hive.metastore.events.PreAlterPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.PreAlterSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.PreAlterTableEvent;
import org.apache.hadoop.hive.metastore.events.PreAuthorizationCallEvent;
import org.apache.hadoop.hive.metastore.events.PreCreateDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.PreCreateISchemaEvent;
+import org.apache.hadoop.hive.metastore.events.PreAddSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.PreCreateTableEvent;
import org.apache.hadoop.hive.metastore.events.PreDropDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.PreDropISchemaEvent;
import org.apache.hadoop.hive.metastore.events.PreDropPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.PreDropSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.PreDropTableEvent;
import org.apache.hadoop.hive.metastore.events.PreEventContext;
import org.apache.hadoop.hive.metastore.events.PreLoadPartitionDoneEvent;
import org.apache.hadoop.hive.metastore.events.PreReadDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.PreReadISchemaEvent;
import org.apache.hadoop.hive.metastore.events.PreReadTableEvent;
+import org.apache.hadoop.hive.metastore.events.PreReadhSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.messaging.EventMessage.EventType;
import org.apache.hadoop.hive.metastore.metrics.JvmPauseMonitor;
import org.apache.hadoop.hive.metastore.metrics.Metrics;
@@ -7106,7 +7121,6 @@ public class HiveMetaStore extends ThriftHiveMetastore {
}
}
-
@Override
public WMCreateResourcePlanResponse create_resource_plan(WMCreateResourcePlanRequest request)
throws AlreadyExistsException, InvalidObjectException, MetaException, TException {
@@ -7254,7 +7268,8 @@ public class HiveMetaStore extends ThriftHiveMetastore {
WMGetTriggersForResourePlanRequest request)
throws NoSuchObjectException, MetaException, TException {
try {
- List<WMTrigger> triggers = getMS().getTriggersForResourcePlan(request.getResourcePlanName());
+ List<WMTrigger> triggers =
+ getMS().getTriggersForResourcePlan(request.getResourcePlanName());
WMGetTriggersForResourePlanResponse response = new WMGetTriggersForResourePlanResponse();
response.setTriggers(triggers);
return response;
@@ -7264,33 +7279,31 @@ public class HiveMetaStore extends ThriftHiveMetastore {
}
}
- @Override
- public WMCreatePoolResponse create_wm_pool(WMCreatePoolRequest request)
+ public WMAlterPoolResponse alter_wm_pool(WMAlterPoolRequest request)
throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException,
TException {
try {
- getMS().createPool(request.getPool());
- return new WMCreatePoolResponse();
+ getMS().alterPool(request.getPool(), request.getPoolPath());
+ return new WMAlterPoolResponse();
} catch (MetaException e) {
- LOG.error("Exception while trying to create WMPool", e);
+ LOG.error("Exception while trying to alter WMPool", e);
throw e;
}
}
@Override
- public WMAlterPoolResponse alter_wm_pool(WMAlterPoolRequest request)
+ public WMCreatePoolResponse create_wm_pool(WMCreatePoolRequest request)
throws AlreadyExistsException, NoSuchObjectException, InvalidObjectException, MetaException,
TException {
try {
- getMS().alterPool(request.getPool(), request.getPoolPath());
- return new WMAlterPoolResponse();
+ getMS().createPool(request.getPool());
+ return new WMCreatePoolResponse();
} catch (MetaException e) {
- LOG.error("Exception while trying to alter WMPool", e);
+ LOG.error("Exception while trying to create WMPool", e);
throw e;
}
}
- @Override
public WMDropPoolResponse drop_wm_pool(WMDropPoolRequest request)
throws NoSuchObjectException, InvalidOperationException, MetaException, TException {
try {
@@ -7302,7 +7315,6 @@ public class HiveMetaStore extends ThriftHiveMetastore {
}
}
- @Override
public WMCreateOrUpdateMappingResponse create_or_update_wm_mapping(
WMCreateOrUpdateMappingRequest request) throws AlreadyExistsException,
NoSuchObjectException, InvalidObjectException, MetaException, TException {
@@ -7315,7 +7327,6 @@ public class HiveMetaStore extends ThriftHiveMetastore {
}
}
- @Override
public WMDropMappingResponse drop_wm_mapping(WMDropMappingRequest request)
throws NoSuchObjectException, InvalidOperationException, MetaException, TException {
try {
@@ -7327,7 +7338,6 @@ public class HiveMetaStore extends ThriftHiveMetastore {
}
}
- @Override
public WMCreateOrDropTriggerToPoolMappingResponse create_or_drop_wm_trigger_to_pool_mapping(
WMCreateOrDropTriggerToPoolMappingRequest request) throws AlreadyExistsException,
NoSuchObjectException, InvalidObjectException, MetaException, TException {
@@ -7345,6 +7355,438 @@ public class HiveMetaStore extends ThriftHiveMetastore {
throw e;
}
}
+
+ public void create_ischema(ISchema schema) throws TException {
+ startFunction("create_ischema", ": " + schema.getName());
+ boolean success = false;
+ Exception ex = null;
+ RawStore ms = getMS();
+ try {
+ firePreEvent(new PreCreateISchemaEvent(this, schema));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.createISchema(schema);
+
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.CREATE_ISCHEMA, new CreateISchemaEvent(true, this, schema));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.CREATE_ISCHEMA,
+ new CreateISchemaEvent(success, this, schema), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|AlreadyExistsException e) {
+ LOG.error("Caught exception creating schema", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("create_ischema", success, ex);
+ }
+ }
+
+ @Override
+ public void alter_ischema(AlterISchemaRequest rqst) throws TException {
+ startFunction("alter_ischema", ": " + rqst);
+ boolean success = false;
+ Exception ex = null;
+ RawStore ms = getMS();
+ try {
+ ISchema oldSchema = ms.getISchema(rqst.getName());
+ if (oldSchema == null) {
+ throw new NoSuchObjectException("Could not find schema " + rqst.getName());
+ }
+ firePreEvent(new PreAlterISchemaEvent(this, oldSchema, rqst.getNewSchema()));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.alterISchema(rqst.getName(), rqst.getNewSchema());
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.ALTER_ISCHEMA, new AlterISchemaEvent(true, this, oldSchema, rqst.getNewSchema()));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_ISCHEMA,
+ new AlterISchemaEvent(success, this, oldSchema, rqst.getNewSchema()), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|NoSuchObjectException e) {
+ LOG.error("Caught exception altering schema", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("alter_ischema", success, ex);
+ }
+ }
+
+ @Override
+ public ISchema get_ischema(ISchemaName schemaName) throws TException {
+ startFunction("get_ischema", ": " + schemaName);
+ Exception ex = null;
+ ISchema schema = null;
+ try {
+ schema = getMS().getISchema(schemaName);
+ if (schema == null) {
+ throw new NoSuchObjectException("No schema named " + schemaName + " exists");
+ }
+ firePreEvent(new PreReadISchemaEvent(this, schema));
+ return schema;
+ } catch (MetaException e) {
+ LOG.error("Caught exception getting schema", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_ischema", schema != null, ex);
+ }
+ }
+
+ @Override
+ public void drop_ischema(ISchemaName schemaName) throws TException {
+ startFunction("drop_ischema", ": " + schemaName);
+ Exception ex = null;
+ boolean success = false;
+ RawStore ms = getMS();
+ try {
+ // look for any valid versions. This will also throw NoSuchObjectException if the schema
+ // itself doesn't exist, which is what we want.
+ SchemaVersion latest = ms.getLatestSchemaVersion(schemaName);
+ if (latest != null) {
+ ex = new InvalidOperationException("Schema " + schemaName + " cannot be dropped, it has" +
+ " at least one valid version");
+ throw (InvalidObjectException)ex;
+ }
+ ISchema schema = ms.getISchema(schemaName);
+ firePreEvent(new PreDropISchemaEvent(this, schema));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.dropISchema(schemaName);
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.DROP_ISCHEMA, new DropISchemaEvent(true, this, schema));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.DROP_ISCHEMA,
+ new DropISchemaEvent(success, this, schema), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|NoSuchObjectException e) {
+ LOG.error("Caught exception dropping schema", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("drop_ischema", success, ex);
+ }
+ }
+
+ @Override
+ public void add_schema_version(SchemaVersion schemaVersion) throws TException {
+ startFunction("add_schema_version", ": " + schemaVersion);
+ boolean success = false;
+ Exception ex = null;
+ RawStore ms = getMS();
+ try {
+ // Make sure the referenced schema exists
+ if (ms.getISchema(schemaVersion.getSchema()) == null) {
+ throw new NoSuchObjectException("No schema named " + schemaVersion.getSchema());
+ }
+ firePreEvent(new PreAddSchemaVersionEvent(this, schemaVersion));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.addSchemaVersion(schemaVersion);
+
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.ADD_SCHEMA_VERSION, new AddSchemaVersionEvent(true, this, schemaVersion));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ADD_SCHEMA_VERSION,
+ new AddSchemaVersionEvent(success, this, schemaVersion), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|AlreadyExistsException e) {
+ LOG.error("Caught exception adding schema version", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("add_schema_version", success, ex);
+ }
+ }
+
+ @Override
+ public SchemaVersion get_schema_version(SchemaVersionDescriptor version) throws TException {
+ startFunction("get_schema_version", ": " + version);
+ Exception ex = null;
+ SchemaVersion schemaVersion = null;
+ try {
+ schemaVersion = getMS().getSchemaVersion(version);
+ if (schemaVersion == null) {
+ throw new NoSuchObjectException("No schema version " + version + "exists");
+ }
+ firePreEvent(new PreReadhSchemaVersionEvent(this, Collections.singletonList(schemaVersion)));
+ return schemaVersion;
+ } catch (MetaException e) {
+ LOG.error("Caught exception getting schema version", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_schema_version", schemaVersion != null, ex);
+ }
+ }
+
+ @Override
+ public SchemaVersion get_schema_latest_version(ISchemaName schemaName) throws TException {
+ startFunction("get_latest_schema_version", ": " + schemaName);
+ Exception ex = null;
+ SchemaVersion schemaVersion = null;
+ try {
+ schemaVersion = getMS().getLatestSchemaVersion(schemaName);
+ if (schemaVersion == null) {
+ throw new NoSuchObjectException("No versions of schema " + schemaName + "exist");
+ }
+ firePreEvent(new PreReadhSchemaVersionEvent(this, Collections.singletonList(schemaVersion)));
+ return schemaVersion;
+ } catch (MetaException e) {
+ LOG.error("Caught exception getting latest schema version", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_latest_schema_version", schemaVersion != null, ex);
+ }
+ }
+
+ @Override
+ public List<SchemaVersion> get_schema_all_versions(ISchemaName schemaName) throws TException {
+ startFunction("get_all_schema_versions", ": " + schemaName);
+ Exception ex = null;
+ List<SchemaVersion> schemaVersions = null;
+ try {
+ schemaVersions = getMS().getAllSchemaVersion(schemaName);
+ if (schemaVersions == null) {
+ throw new NoSuchObjectException("No versions of schema " + schemaName + "exist");
+ }
+ firePreEvent(new PreReadhSchemaVersionEvent(this, schemaVersions));
+ return schemaVersions;
+ } catch (MetaException e) {
+ LOG.error("Caught exception getting all schema versions", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_all_schema_versions", schemaVersions != null, ex);
+ }
+ }
+
+ @Override
+ public void drop_schema_version(SchemaVersionDescriptor version) throws TException {
+ startFunction("drop_schema_version", ": " + version);
+ Exception ex = null;
+ boolean success = false;
+ RawStore ms = getMS();
+ try {
+ SchemaVersion schemaVersion = ms.getSchemaVersion(version);
+ if (schemaVersion == null) {
+ throw new NoSuchObjectException("No schema version " + version);
+ }
+ firePreEvent(new PreDropSchemaVersionEvent(this, schemaVersion));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.dropSchemaVersion(version);
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.DROP_SCHEMA_VERSION, new DropSchemaVersionEvent(true, this, schemaVersion));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.DROP_SCHEMA_VERSION,
+ new DropSchemaVersionEvent(success, this, schemaVersion), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|NoSuchObjectException e) {
+ LOG.error("Caught exception dropping schema version", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("drop_schema_version", success, ex);
+ }
+ }
+
+ @Override
+ public FindSchemasByColsResp get_schemas_by_cols(FindSchemasByColsRqst rqst) throws TException {
+ startFunction("get_schemas_by_cols");
+ Exception ex = null;
+ List<SchemaVersion> schemaVersions = Collections.emptyList();
+ try {
+ schemaVersions = getMS().getSchemaVersionsByColumns(rqst.getColName(),
+ rqst.getColNamespace(), rqst.getType());
+ firePreEvent(new PreReadhSchemaVersionEvent(this, schemaVersions));
+ final List<SchemaVersionDescriptor> entries = new ArrayList<>(schemaVersions.size());
+ schemaVersions.forEach(schemaVersion -> entries.add(
+ new SchemaVersionDescriptor(schemaVersion.getSchema(), schemaVersion.getVersion())));
+ return new FindSchemasByColsResp(entries);
+ } catch (MetaException e) {
+ LOG.error("Caught exception doing schema version query", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_schemas_by_cols", !schemaVersions.isEmpty(), ex);
+ }
+ }
+
+ @Override
+ public void map_schema_version_to_serde(MapSchemaVersionToSerdeRequest rqst)
+ throws TException {
+ startFunction("map_schema_version_to_serde, :" + rqst);
+ boolean success = false;
+ Exception ex = null;
+ RawStore ms = getMS();
+ try {
+ SchemaVersion oldSchemaVersion = ms.getSchemaVersion(rqst.getSchemaVersion());
+ if (oldSchemaVersion == null) {
+ throw new NoSuchObjectException("No schema version " + rqst.getSchemaVersion());
+ }
+ SerDeInfo serde = ms.getSerDeInfo(rqst.getSerdeName());
+ if (serde == null) {
+ throw new NoSuchObjectException("No SerDe named " + rqst.getSerdeName());
+ }
+ SchemaVersion newSchemaVersion = new SchemaVersion(oldSchemaVersion);
+ newSchemaVersion.setSerDe(serde);
+ firePreEvent(new PreAlterSchemaVersionEvent(this, oldSchemaVersion, newSchemaVersion));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.alterSchemaVersion(rqst.getSchemaVersion(), newSchemaVersion);
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.ALTER_SCHEMA_VERSION, new AlterSchemaVersionEvent(true, this,
+ oldSchemaVersion, newSchemaVersion));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_SCHEMA_VERSION,
+ new AlterSchemaVersionEvent(success, this, oldSchemaVersion, newSchemaVersion), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|NoSuchObjectException e) {
+ LOG.error("Caught exception mapping schema version to serde", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("map_schema_version_to_serde", success, ex);
+ }
+ }
+
+ @Override
+ public void set_schema_version_state(SetSchemaVersionStateRequest rqst) throws TException {
+ startFunction("set_schema_version_state, :" + rqst);
+ boolean success = false;
+ Exception ex = null;
+ RawStore ms = getMS();
+ try {
+ SchemaVersion oldSchemaVersion = ms.getSchemaVersion(rqst.getSchemaVersion());
+ if (oldSchemaVersion == null) {
+ throw new NoSuchObjectException("No schema version " + rqst.getSchemaVersion());
+ }
+ SchemaVersion newSchemaVersion = new SchemaVersion(oldSchemaVersion);
+ newSchemaVersion.setState(rqst.getState());
+ firePreEvent(new PreAlterSchemaVersionEvent(this, oldSchemaVersion, newSchemaVersion));
+ Map<String, String> transactionalListenersResponses = Collections.emptyMap();
+ ms.openTransaction();
+ try {
+ ms.alterSchemaVersion(rqst.getSchemaVersion(), newSchemaVersion);
+ if (!transactionalListeners.isEmpty()) {
+ transactionalListenersResponses =
+ MetaStoreListenerNotifier.notifyEvent(transactionalListeners,
+ EventType.ALTER_SCHEMA_VERSION, new AlterSchemaVersionEvent(true, this,
+ oldSchemaVersion, newSchemaVersion));
+ }
+ success = ms.commitTransaction();
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ if (!listeners.isEmpty()) {
+ MetaStoreListenerNotifier.notifyEvent(listeners, EventType.ALTER_SCHEMA_VERSION,
+ new AlterSchemaVersionEvent(success, this, oldSchemaVersion, newSchemaVersion), null,
+ transactionalListenersResponses, ms);
+ }
+ }
+ } catch (MetaException|NoSuchObjectException e) {
+ LOG.error("Caught exception changing schema version state", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("set_schema_version_state", success, ex);
+ }
+ }
+
+ @Override
+ public void add_serde(SerDeInfo serde) throws TException {
+ startFunction("create_serde", ": " + serde.getName());
+ Exception ex = null;
+ boolean success = false;
+ RawStore ms = getMS();
+ try {
+ ms.openTransaction();
+ ms.addSerde(serde);
+ success = ms.commitTransaction();
+ } catch (MetaException|AlreadyExistsException e) {
+ LOG.error("Caught exception creating serde", e);
+ ex = e;
+ throw e;
+ } finally {
+ if (!success) ms.rollbackTransaction();
+ endFunction("create_serde", success, ex);
+ }
+ }
+
+ @Override
+ public SerDeInfo get_serde(GetSerdeRequest rqst) throws TException {
+ startFunction("get_serde", ": " + rqst);
+ Exception ex = null;
+ SerDeInfo serde = null;
+ try {
+ serde = getMS().getSerDeInfo(rqst.getSerdeName());
+ if (serde == null) {
+ throw new NoSuchObjectException("No serde named " + rqst.getSerdeName() + " exists");
+ }
+ return serde;
+ } catch (MetaException e) {
+ LOG.error("Caught exception getting serde", e);
+ ex = e;
+ throw e;
+ } finally {
+ endFunction("get_serde", serde != null, ex);
+ }
+ }
}
private static IHMSHandler newRetryingHMSHandler(IHMSHandler baseHandler, Configuration conf)
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
index 3128089..1755700b 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
@@ -2794,4 +2794,76 @@ public class HiveMetaStoreClient implements IMetaStoreClient, AutoCloseable {
client.create_or_drop_wm_trigger_to_pool_mapping(request);
}
+ public void createISchema(ISchema schema) throws TException {
+ client.create_ischema(schema);
+ }
+
+ @Override
+ public void alterISchema(String dbName, String schemaName, ISchema newSchema) throws TException {
+ client.alter_ischema(new AlterISchemaRequest(new ISchemaName(dbName, schemaName), newSchema));
+ }
+
+ @Override
+ public ISchema getISchema(String dbName, String name) throws TException {
+ return client.get_ischema(new ISchemaName(dbName, name));
+ }
+
+ @Override
+ public void dropISchema(String dbName, String name) throws TException {
+ client.drop_ischema(new ISchemaName(dbName, name));
+ }
+
+ @Override
+ public void addSchemaVersion(SchemaVersion schemaVersion) throws TException {
+ client.add_schema_version(schemaVersion);
+ }
+
+ @Override
+ public SchemaVersion getSchemaVersion(String dbName, String schemaName, int version) throws TException {
+ return client.get_schema_version(new SchemaVersionDescriptor(new ISchemaName(dbName, schemaName), version));
+ }
+
+ @Override
+ public SchemaVersion getSchemaLatestVersion(String dbName, String schemaName) throws TException {
+ return client.get_schema_latest_version(new ISchemaName(dbName, schemaName));
+ }
+
+ @Override
+ public List<SchemaVersion> getSchemaAllVersions(String dbName, String schemaName) throws TException {
+ return client.get_schema_all_versions(new ISchemaName(dbName, schemaName));
+ }
+
+ @Override
+ public void dropSchemaVersion(String dbName, String schemaName, int version) throws TException {
+ client.drop_schema_version(new SchemaVersionDescriptor(new ISchemaName(dbName, schemaName), version));
+ }
+
+ @Override
+ public FindSchemasByColsResp getSchemaByCols(FindSchemasByColsRqst rqst) throws TException {
+ return client.get_schemas_by_cols(rqst);
+ }
+
+ @Override
+ public void mapSchemaVersionToSerde(String dbName, String schemaName, int version, String serdeName)
+ throws TException {
+ client.map_schema_version_to_serde(new MapSchemaVersionToSerdeRequest(
+ new SchemaVersionDescriptor(new ISchemaName(dbName, schemaName), version), serdeName));
+ }
+
+ @Override
+ public void setSchemaVersionState(String dbName, String schemaName, int version, SchemaVersionState state)
+ throws TException {
+ client.set_schema_version_state(new SetSchemaVersionStateRequest(new SchemaVersionDescriptor(
+ new ISchemaName(dbName, schemaName), version), state));
+ }
+
+ @Override
+ public void addSerDe(SerDeInfo serDeInfo) throws TException {
+ client.add_serde(serDeInfo);
+ }
+
+ @Override
+ public SerDeInfo getSerDe(String serDeName) throws TException {
+ return client.get_serde(new GetSerdeRequest(serDeName));
+ }
}
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
index 46984cb..f1d5066 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
@@ -49,6 +49,8 @@ import org.apache.hadoop.hive.metastore.api.DefaultConstraintsRequest;
import org.apache.hadoop.hive.metastore.api.Database;
import org.apache.hadoop.hive.metastore.api.EnvironmentContext;
import org.apache.hadoop.hive.metastore.api.FieldSchema;
+import org.apache.hadoop.hive.metastore.api.FindSchemasByColsResp;
+import org.apache.hadoop.hive.metastore.api.FindSchemasByColsRqst;
import org.apache.hadoop.hive.metastore.api.FireEventRequest;
import org.apache.hadoop.hive.metastore.api.FireEventResponse;
import org.apache.hadoop.hive.metastore.api.ForeignKeysRequest;
@@ -62,6 +64,7 @@ import org.apache.hadoop.hive.metastore.api.GetRoleGrantsForPrincipalResponse;
import org.apache.hadoop.hive.metastore.api.HeartbeatTxnRangeResponse;
import org.apache.hadoop.hive.metastore.api.HiveObjectPrivilege;
import org.apache.hadoop.hive.metastore.api.HiveObjectRef;
+import org.apache.hadoop.hive.metastore.api.ISchema;
import org.apache.hadoop.hive.metastore.api.InvalidInputException;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
@@ -94,6 +97,9 @@ import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint;
import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
import org.apache.hadoop.hive.metastore.api.SQLUniqueConstraint;
+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.SetPartitionsStatsRequest;
import org.apache.hadoop.hive.metastore.api.ShowCompactResponse;
import org.apache.hadoop.hive.metastore.api.ShowLocksRequest;
@@ -1828,4 +1834,165 @@ public interface IMetaStoreClient {
void createOrDropTriggerToPoolMapping(String resourcePlanName, String triggerName,
String poolPath, boolean shouldDrop) throws AlreadyExistsException, NoSuchObjectException,
InvalidObjectException, MetaException, TException;
+
+ /**
+ * Create a new schema. This is really a schema container, as there will be specific versions
+ * of the schema that have columns, etc.
+ * @param schema schema to create
+ * @throws AlreadyExistsException if a schema of this name already exists
+ * @throws NoSuchObjectException database references by this schema does not exist
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void createISchema(ISchema schema) throws TException;
+
+ /**
+ * Alter an existing schema.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @param newSchema altered schema object
+ * @throws NoSuchObjectException no schema with this name could be found
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void alterISchema(String dbName, String schemaName, ISchema newSchema) throws TException;
+
+ /**
+ * Fetch a schema.
+ * @param dbName database the schema is in
+ * @param name name of the schema
+ * @return the schema or null if no such schema
+ * @throws NoSuchObjectException no schema matching this name exists
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ ISchema getISchema(String dbName, String name) throws TException;
+
+ /**
+ * Drop an existing schema. If there are schema versions of this, this call will fail.
+ * @param dbName database the schema is in
+ * @param name name of the schema to drop
+ * @throws NoSuchObjectException no schema with this name could be found
+ * @throws InvalidOperationException attempt to drop a schema that has versions
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void dropISchema(String dbName, String name) throws TException;
+
+ /**
+ * Add a new version to an existing schema.
+ * @param schemaVersion version object to add
+ * @throws AlreadyExistsException a version of this schema with the same version id already exists
+ * @throws NoSuchObjectException no schema with this name could be found
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void addSchemaVersion(SchemaVersion schemaVersion) throws TException;
+
+ /**
+ * Get a specific version of a schema.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @param version version of the schema
+ * @return the schema version or null if no such schema version
+ * @throws NoSuchObjectException no schema matching this name and version exists
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ SchemaVersion getSchemaVersion(String dbName, String schemaName, int version) throws TException;
+
+ /**
+ * Get the latest version of a schema.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @return latest version of the schema or null if the schema does not exist or there are no
+ * version of the schema.
+ * @throws NoSuchObjectException no versions of schema matching this name exist
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ SchemaVersion getSchemaLatestVersion(String dbName, String schemaName) throws TException;
+
+ /**
+ * Get all the extant versions of a schema.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema.
+ * @return list of all the schema versions or null if this schema does not exist or has no
+ * versions.
+ * @throws NoSuchObjectException no versions of schema matching this name exist
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ List<SchemaVersion> getSchemaAllVersions(String dbName, String schemaName) throws TException;
+
+ /**
+ * Drop a version of a schema. Given that versions are supposed to be immutable you should
+ * think really hard before you call this method. It should only be used for schema versions
+ * that were added in error and never referenced any data.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @param version version of the schema
+ * @throws NoSuchObjectException no matching version of the schema could be found
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void dropSchemaVersion(String dbName, String schemaName, int version) throws TException;
+
+ /**
+ * Find all schema versions that have columns that match a query.
+ * @param rqst query, this can include column names, namespaces (actually stored in the
+ * description field in FieldSchema), and types.
+ * @return The (possibly empty) list of schema name/version pairs that match.
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ FindSchemasByColsResp getSchemaByCols(FindSchemasByColsRqst rqst) throws TException;
+
+ /**
+ * Map a schema version to a serde. This mapping is one-to-one, thus this will destroy any
+ * previous mappings for this schema version.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @param version version of the schema
+ * @param serdeName name of the serde
+ * @throws NoSuchObjectException no matching version of the schema could be found or no serde
+ * of the provided name could be found
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void mapSchemaVersionToSerde(String dbName, String schemaName, int version, String serdeName) throws TException;
+
+ /**
+ * Set the state of a schema version.
+ * @param dbName database the schema is in
+ * @param schemaName name of the schema
+ * @param version version of the schema
+ * @param state state to set the schema too
+ * @throws NoSuchObjectException no matching version of the schema could be found
+ * @throws InvalidOperationException attempt to make a state change that is not valid
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void setSchemaVersionState(String dbName, String schemaName, int version, SchemaVersionState state) throws TException;
+
+ /**
+ * Add a serde. This is primarily intended for use with SchemaRegistry objects, since serdes
+ * are automatically added when needed as part of creating and altering tables and partitions.
+ * @param serDeInfo serde to add
+ * @throws AlreadyExistsException serde of this name already exists
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ void addSerDe(SerDeInfo serDeInfo) throws TException;
+
+ /**
+ * Fetch a serde. This is primarily intended for use with SchemaRegistry objects, since serdes
+ * are automatically fetched along with other information for tables and partitions.
+ * @param serDeName name of the serde
+ * @return the serde.
+ * @throws NoSuchObjectException no serde with this name exists.
+ * @throws MetaException general metastore error
+ * @throws TException general thrift error
+ */
+ SerDeInfo getSerDe(String serDeName) throws TException;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java
index 88d22d6..67600e1 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreEventListener.java
@@ -26,19 +26,25 @@ import org.apache.hadoop.hive.metastore.api.MetaException;
import org.apache.hadoop.hive.metastore.events.AddForeignKeyEvent;
import org.apache.hadoop.hive.metastore.events.AddNotNullConstraintEvent;
import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent;
+import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent;
import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent;
import org.apache.hadoop.hive.metastore.events.AddPartitionEvent;
import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.AlterSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.AlterTableEvent;
import org.apache.hadoop.hive.metastore.events.ConfigChangeEvent;
import org.apache.hadoop.hive.metastore.events.CreateDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.CreateFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.CreateISchemaEvent;
import org.apache.hadoop.hive.metastore.events.CreateTableEvent;
import org.apache.hadoop.hive.metastore.events.DropConstraintEvent;
import org.apache.hadoop.hive.metastore.events.DropDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.DropFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.DropISchemaEvent;
import org.apache.hadoop.hive.metastore.events.DropPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.DropSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.DropTableEvent;
import org.apache.hadoop.hive.metastore.events.InsertEvent;
import org.apache.hadoop.hive.metastore.events.LoadPartitionDoneEvent;
@@ -196,6 +202,26 @@ public abstract class MetaStoreEventListener implements Configurable {
public void onDropConstraint(DropConstraintEvent dropConstraintEvent) throws MetaException {
}
+ public void onCreateISchema(CreateISchemaEvent createISchemaEvent) throws MetaException {
+ }
+
+ public void onAlterISchema(AlterISchemaEvent alterISchemaEvent) throws MetaException {
+ }
+
+ public void onDropISchema(DropISchemaEvent dropISchemaEvent) throws MetaException {
+ }
+
+ public void onAddSchemaVersion(AddSchemaVersionEvent addSchemaVersionEvent) throws MetaException {
+ }
+
+ public void onAlterSchemaVersion(AlterSchemaVersionEvent alterSchemaVersionEvent)
+ throws MetaException {
+ }
+
+ public void onDropSchemaVersion(DropSchemaVersionEvent dropSchemaVersionEvent)
+ throws MetaException {
+ }
+
@Override
public Configuration getConf() {
return this.conf;
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java
index af01e8a..f5a91b4 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/MetaStoreListenerNotifier.java
@@ -28,16 +28,22 @@ import org.apache.hadoop.hive.metastore.events.AddForeignKeyEvent;
import org.apache.hadoop.hive.metastore.events.AddNotNullConstraintEvent;
import org.apache.hadoop.hive.metastore.events.AddPartitionEvent;
import org.apache.hadoop.hive.metastore.events.AddPrimaryKeyEvent;
+import org.apache.hadoop.hive.metastore.events.AddSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.AddUniqueConstraintEvent;
import org.apache.hadoop.hive.metastore.events.AlterDatabaseEvent;
+import org.apache.hadoop.hive.metastore.events.AlterISchemaEvent;
import org.apache.hadoop.hive.metastore.events.AlterPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.AlterSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.AlterTableEvent;
import org.apache.hadoop.hive.metastore.events.CreateDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.CreateFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.CreateISchemaEvent;
import org.apache.hadoop.hive.metastore.events.CreateTableEvent;
import org.apache.hadoop.hive.metastore.events.DropDatabaseEvent;
import org.apache.hadoop.hive.metastore.events.DropFunctionEvent;
+import org.apache.hadoop.hive.metastore.events.DropISchemaEvent;
import org.apache.hadoop.hive.metastore.events.DropPartitionEvent;
+import org.apache.hadoop.hive.metastore.events.DropSchemaVersionEvent;
import org.apache.hadoop.hive.metastore.events.DropTableEvent;
import org.apache.hadoop.hive.metastore.events.InsertEvent;
import org.apache.hadoop.hive.metastore.events.ListenerEvent;
@@ -158,6 +164,42 @@ public class MetaStoreListenerNotifier {
listener.onAddNotNullConstraint((AddNotNullConstraintEvent)event);
}
})
+ .put(EventType.CREATE_ISCHEMA, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onCreateISchema((CreateISchemaEvent)event);
+ }
+ })
+ .put(EventType.ALTER_ISCHEMA, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onAlterISchema((AlterISchemaEvent)event);
+ }
+ })
+ .put(EventType.DROP_ISCHEMA, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onDropISchema((DropISchemaEvent)event);
+ }
+ })
+ .put(EventType.ADD_SCHEMA_VERSION, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onAddSchemaVersion((AddSchemaVersionEvent) event);
+ }
+ })
+ .put(EventType.ALTER_SCHEMA_VERSION, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onAlterSchemaVersion((AlterSchemaVersionEvent) event);
+ }
+ })
+ .put(EventType.DROP_SCHEMA_VERSION, new EventNotifier() {
+ @Override
+ public void notify(MetaStoreEventListener listener, ListenerEvent event) throws MetaException {
+ listener.onDropSchemaVersion((DropSchemaVersionEvent) event);
+ }
+ })
.build()
);
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java
index 3633c03..1f75105 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/ObjectStore.java
@@ -92,6 +92,8 @@ import org.apache.hadoop.hive.metastore.api.FunctionType;
import org.apache.hadoop.hive.metastore.api.HiveObjectPrivilege;
import org.apache.hadoop.hive.metastore.api.HiveObjectRef;
import org.apache.hadoop.hive.metastore.api.HiveObjectType;
+import org.apache.hadoop.hive.metastore.api.ISchema;
+import org.apache.hadoop.hive.metastore.api.ISchemaName;
import org.apache.hadoop.hive.metastore.api.InvalidInputException;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
@@ -121,7 +123,14 @@ import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint;
import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
import org.apache.hadoop.hive.metastore.api.SQLUniqueConstraint;
+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.SchemaVersionDescriptor;
+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.api.SkewedInfo;
import org.apache.hadoop.hive.metastore.api.StorageDescriptor;
import org.apache.hadoop.hive.metastore.api.Table;
@@ -155,6 +164,7 @@ import org.apache.hadoop.hive.metastore.model.MDelegationToken;
import org.apache.hadoop.hive.metastore.model.MFieldSchema;
import org.apache.hadoop.hive.metastore.model.MFunction;
import org.apache.hadoop.hive.metastore.model.MGlobalPrivilege;
+import org.apache.hadoop.hive.metastore.model.MISchema;
import org.apache.hadoop.hive.metastore.model.MMasterKey;
import org.apache.hadoop.hive.metastore.model.MMetastoreDBProperties;
import org.apache.hadoop.hive.metastore.model.MNotificationLog;
@@ -168,6 +178,7 @@ import org.apache.hadoop.hive.metastore.model.MPartitionPrivilege;
import org.apache.hadoop.hive.metastore.model.MResourceUri;
import org.apache.hadoop.hive.metastore.model.MRole;
import org.apache.hadoop.hive.metastore.model.MRoleMap;
+import org.apache.hadoop.hive.metastore.model.MSchemaVersion;
import org.apache.hadoop.hive.metastore.model.MSerDeInfo;
import org.apache.hadoop.hive.metastore.model.MStorageDescriptor;
import org.apache.hadoop.hive.metastore.model.MStringList;
@@ -1780,15 +1791,22 @@ public class ObjectStore implements RawStore, Configurable {
if (ms == null) {
throw new MetaException("Invalid SerDeInfo object");
}
- return new SerDeInfo(ms.getName(), ms.getSerializationLib(), convertMap(ms.getParameters()));
+ SerDeInfo serde =
+ new SerDeInfo(ms.getName(), ms.getSerializationLib(), convertMap(ms.getParameters()));
+ if (ms.getDescription() != null) serde.setDescription(ms.getDescription());
+ if (ms.getSerializerClass() != null) serde.setSerializerClass(ms.getSerializerClass());
+ if (ms.getDeserializerClass() != null) serde.setDeserializerClass(ms.getDeserializerClass());
+ if (ms.getSerdeType() > 0) serde.setSerdeType(SerdeType.findByValue(ms.getSerdeType()));
+ return serde;
}
private MSerDeInfo convertToMSerDeInfo(SerDeInfo ms) throws MetaException {
if (ms == null) {
throw new MetaException("Invalid SerDeInfo object");
}
- return new MSerDeInfo(ms.getName(), ms.getSerializationLib(), ms
- .getParameters());
+ return new MSerDeInfo(ms.getName(), ms.getSerializationLib(), ms.getParameters(),
+ ms.getDescription(), ms.getSerializerClass(), ms.getDeserializerClass(),
+ ms.getSerdeType() == null ? 0 : ms.getSerdeType().getValue());
}
/**
@@ -9569,6 +9587,408 @@ public class ObjectStore implements RawStore, Configurable {
}
}
+ @Override
+ public void createISchema(ISchema schema) throws AlreadyExistsException, MetaException,
+ NoSuchObjectException {
+ boolean committed = false;
+ MISchema mSchema = convertToMISchema(schema);
+ try {
+ openTransaction();
+ if (getMISchema(schema.getDbName(), schema.getName()) != null) {
+ throw new AlreadyExistsException("Schema with name " + schema.getDbName() + "." +
+ schema.getName() + " already exists");
+ }
+ pm.makePersistent(mSchema);
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+ }
+
+ @Override
+ public void alterISchema(ISchemaName schemaName, ISchema newSchema)
+ throws NoSuchObjectException, MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ MISchema oldMSchema = getMISchema(schemaName.getDbName(), schemaName.getSchemaName());
+ if (oldMSchema == null) {
+ throw new NoSuchObjectException("Schema " + schemaName + " does not exist");
+ }
+
+ // Don't support changing name or type
+ oldMSchema.setCompatibility(newSchema.getCompatibility().getValue());
+ oldMSchema.setValidationLevel(newSchema.getValidationLevel().getValue());
+ oldMSchema.setCanEvolve(newSchema.isCanEvolve());
+ if (newSchema.isSetSchemaGroup()) oldMSchema.setSchemaGroup(newSchema.getSchemaGroup());
+ if (newSchema.isSetDescription()) oldMSchema.setDescription(newSchema.getDescription());
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+ }
+
+ @Override
+ public ISchema getISchema(ISchemaName schemaName) throws MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ ISchema schema = convertToISchema(getMISchema(schemaName.getDbName(), schemaName.getSchemaName()));
+ committed = commitTransaction();
+ return schema;
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+ }
+
+ private MISchema getMISchema(String dbName, String name) {
+ Query query = null;
+ try {
+ name = normalizeIdentifier(name);
+ dbName = normalizeIdentifier(dbName);
+ query = pm.newQuery(MISchema.class, "name == schemaName && db.name == dbname");
+ query.declareParameters("java.lang.String schemaName, java.lang.String dbname");
+ query.setUnique(true);
+ MISchema mSchema = (MISchema)query.execute(name, dbName);
+ pm.retrieve(mSchema);
+ return mSchema;
+ } finally {
+ if (query != null) query.closeAll();
+ }
+ }
+
+ @Override
+ public void dropISchema(ISchemaName schemaName) throws NoSuchObjectException, MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ MISchema mSchema = getMISchema(schemaName.getDbName(), schemaName.getSchemaName());
+ if (mSchema != null) {
+ pm.deletePersistentAll(mSchema);
+ } else {
+ throw new NoSuchObjectException("Schema " + schemaName + " does not exist");
+ }
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+ }
+
+ @Override
+ public void addSchemaVersion(SchemaVersion schemaVersion)
+ throws AlreadyExistsException, NoSuchObjectException, MetaException {
+ boolean committed = false;
+ MSchemaVersion mSchemaVersion = convertToMSchemaVersion(schemaVersion);
+ try {
+ openTransaction();
+ // Make sure it doesn't already exist
+ if (getMSchemaVersion(schemaVersion.getSchema().getDbName(),
+ schemaVersion.getSchema().getSchemaName(), schemaVersion.getVersion()) != null) {
+ throw new AlreadyExistsException("Schema name " + schemaVersion.getSchema() +
+ " version " + schemaVersion.getVersion() + " already exists");
+ }
+ // Make sure the referenced Schema exists
+ if (getMISchema(schemaVersion.getSchema().getDbName(), schemaVersion.getSchema().getSchemaName()) == null) {
+ throw new NoSuchObjectException("Schema " + schemaVersion.getSchema() + " does not exist");
+ }
+ pm.makePersistent(mSchemaVersion);
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();;
+ }
+ }
+
+ @Override
+ public void alterSchemaVersion(SchemaVersionDescriptor version, SchemaVersion newVersion)
+ throws NoSuchObjectException, MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ MSchemaVersion oldMSchemaVersion = getMSchemaVersion(version.getSchema().getDbName(),
+ version.getSchema().getSchemaName(), version.getVersion());
+ if (oldMSchemaVersion == null) {
+ throw new NoSuchObjectException("No schema version " + version + " exists");
+ }
+
+ // We only support changing the SerDe mapping and the state.
+ if (newVersion.isSetSerDe()) oldMSchemaVersion.setSerDe(convertToMSerDeInfo(newVersion.getSerDe()));
+ if (newVersion.isSetState()) oldMSchemaVersion.setState(newVersion.getState().getValue());
+ committed = commitTransaction();
+ } finally {
+ if (!committed) commitTransaction();
+ }
+ }
+
+ @Override
+ public SchemaVersion getSchemaVersion(SchemaVersionDescriptor version) throws MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ SchemaVersion schemaVersion =
+ convertToSchemaVersion(getMSchemaVersion(version.getSchema().getDbName(),
+ version.getSchema().getSchemaName(), version.getVersion()));
+ committed = commitTransaction();
+ return schemaVersion;
+ } finally {
+ if (!committed) rollbackTransaction();;
+ }
+ }
+
+ private MSchemaVersion getMSchemaVersion(String dbName, String schemaName, int version) {
+ Query query = null;
+ try {
+ dbName = normalizeIdentifier(dbName);
+ schemaName = normalizeIdentifier(schemaName);
+ query = pm.newQuery(MSchemaVersion.class,
+ "iSchema.name == schemaName && iSchema.db.name == dbName && version == schemaVersion");
+ query.declareParameters(
+ "java.lang.String schemaName, java.lang.String dbName, java.lang.Integer schemaVersion");
+ query.setUnique(true);
+ MSchemaVersion mSchemaVersion = (MSchemaVersion)query.execute(schemaName, dbName, version);
+ pm.retrieve(mSchemaVersion);
+ if (mSchemaVersion != null) {
+ pm.retrieveAll(mSchemaVersion.getCols());
+ if (mSchemaVersion.getSerDe() != null) pm.retrieve(mSchemaVersion.getSerDe());
+ }
+ return mSchemaVersion;
+ } finally {
+ if (query != null) query.closeAll();
+ }
+ }
+
+ @Override
+ public SchemaVersion getLatestSchemaVersion(ISchemaName schemaName) throws MetaException {
+ boolean committed = false;
+ Query query = null;
+ try {
+ openTransaction();
+ String name = normalizeIdentifier(schemaName.getSchemaName());
+ String dbName = normalizeIdentifier(schemaName.getDbName());
+ query = pm.newQuery(MSchemaVersion.class,
+ "iSchema.name == schemaName && iSchema.db.name == dbName");
+ query.declareParameters("java.lang.String schemaName, java.lang.String dbName");
+ query.setUnique(true);
+ query.setOrdering("version descending");
+ query.setRange(0, 1);
+ MSchemaVersion mSchemaVersion = (MSchemaVersion)query.execute(name, dbName);
+ pm.retrieve(mSchemaVersion);
+ if (mSchemaVersion != null) {
+ pm.retrieveAll(mSchemaVersion.getCols());
+ if (mSchemaVersion.getSerDe() != null) pm.retrieve(mSchemaVersion.getSerDe());
+ }
+ SchemaVersion version = mSchemaVersion == null ? null : convertToSchemaVersion(mSchemaVersion);
+ committed = commitTransaction();
+ return version;
+ } finally {
+ rollbackAndCleanup(committed, query);
+ }
+ }
+
+ @Override
+ public List<SchemaVersion> getAllSchemaVersion(ISchemaName schemaName) throws MetaException {
+ boolean committed = false;
+ Query query = null;
+ try {
+ openTransaction();
+ String name = normalizeIdentifier(schemaName.getSchemaName());
+ String dbName = normalizeIdentifier(schemaName.getDbName());
+ query = pm.newQuery(MSchemaVersion.class,
+ "iSchema.name == schemaName && iSchema.db.name == dbName");
+ query.declareParameters("java.lang.String schemaName, java.lang.String dbName");
+ query.setOrdering("version descending");
+ List<MSchemaVersion> mSchemaVersions = query.setParameters(name, dbName).executeList();
+ pm.retrieveAll(mSchemaVersions);
+ if (mSchemaVersions == null || mSchemaVersions.isEmpty()) return null;
+ List<SchemaVersion> schemaVersions = new ArrayList<>(mSchemaVersions.size());
+ for (MSchemaVersion mSchemaVersion : mSchemaVersions) {
+ pm.retrieveAll(mSchemaVersion.getCols());
+ if (mSchemaVersion.getSerDe() != null) pm.retrieve(mSchemaVersion.getSerDe());
+ schemaVersions.add(convertToSchemaVersion(mSchemaVersion));
+ }
+ committed = commitTransaction();
+ return schemaVersions;
+ } finally {
+ rollbackAndCleanup(committed, query);
+ }
+ }
+
+ @Override
+ public List<SchemaVersion> getSchemaVersionsByColumns(String colName, String colNamespace,
+ String type) throws MetaException {
+ if (colName == null && colNamespace == null) {
+ // Don't allow a query that returns everything, it will blow stuff up.
+ throw new MetaException("You must specify column name or column namespace, else your query " +
+ "may be too large");
+ }
+ boolean committed = false;
+ Query query = null;
+ try {
+ openTransaction();
+ if (colName != null) colName = normalizeIdentifier(colName);
+ if (type != null) type = normalizeIdentifier(type);
+ Map<String, String> parameters = new HashMap<>(3);
+ StringBuilder sql = new StringBuilder("select SCHEMA_VERSION_ID from " +
+ "SCHEMA_VERSION, COLUMNS_V2 where SCHEMA_VERSION.CD_ID = COLUMNS_V2.CD_ID ");
+ if (colName != null) {
+ sql.append("and COLUMNS_V2.COLUMN_NAME = :colName ");
+ parameters.put("colName", colName);
+ }
+ if (colNamespace != null) {
+ sql.append("and COLUMNS_V2.COMMENT = :colComment ");
+ parameters.put("colComment", colNamespace);
+ }
+ if (type != null) {
+ sql.append("and COLUMNS_V2.TYPE_NAME = :colType ");
+ parameters.put("colType", type);
+ }
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("getSchemaVersionsByColumns going to execute query " + sql.toString());
+ LOG.debug("With parameters");
+ for (Map.Entry<String, String> p : parameters.entrySet()) {
+ LOG.debug(p.getKey() + " : " + p.getValue());
+ }
+ }
+ query = pm.newQuery("javax.jdo.query.SQL", sql.toString());
+ query.setClass(MSchemaVersion.class);
+ List<MSchemaVersion> mSchemaVersions = query.setNamedParameters(parameters).executeList();
+ if (mSchemaVersions == null || mSchemaVersions.isEmpty()) return Collections.emptyList();
+ pm.retrieveAll(mSchemaVersions);
+ List<SchemaVersion> schemaVersions = new ArrayList<>(mSchemaVersions.size());
+ for (MSchemaVersion mSchemaVersion : mSchemaVersions) {
+ pm.retrieveAll(mSchemaVersion.getCols());
+ if (mSchemaVersion.getSerDe() != null) pm.retrieve(mSchemaVersion.getSerDe());
+ schemaVersions.add(convertToSchemaVersion(mSchemaVersion));
+ }
+ committed = commitTransaction();
+ return schemaVersions;
+ } finally {
+ rollbackAndCleanup(committed, query);
+ }
+
+ }
+
+ @Override
+ public void dropSchemaVersion(SchemaVersionDescriptor version) throws NoSuchObjectException,
+ MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ MSchemaVersion mSchemaVersion = getMSchemaVersion(version.getSchema().getDbName(),
+ version.getSchema().getSchemaName(), version.getVersion());
+ if (mSchemaVersion != null) {
+ pm.deletePersistentAll(mSchemaVersion);
+ } else {
+ throw new NoSuchObjectException("Schema version " + version + "does not exist");
+ }
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+ }
+
+ @Override
+ public SerDeInfo getSerDeInfo(String serDeName) throws NoSuchObjectException, MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ MSerDeInfo mSerDeInfo = getMSerDeInfo(serDeName);
+ if (mSerDeInfo == null) {
+ throw new NoSuchObjectException("No SerDe named " + serDeName);
+ }
+ SerDeInfo serde = convertToSerDeInfo(mSerDeInfo);
+ committed = commitTransaction();
+ return serde;
+ } finally {
+ if (!committed) rollbackTransaction();;
+ }
+ }
+
+ private MSerDeInfo getMSerDeInfo(String serDeName) throws MetaException {
+ Query query = null;
+ try {
+ query = pm.newQuery(MSerDeInfo.class, "name == serDeName");
+ query.declareParameters("java.lang.String serDeName");
+ query.setUnique(true);
+ MSerDeInfo mSerDeInfo = (MSerDeInfo)query.execute(serDeName);
+ pm.retrieve(mSerDeInfo);
+ return mSerDeInfo;
+ } finally {
+ if (query != null) query.closeAll();
+ }
+ }
+
+ @Override
+ public void addSerde(SerDeInfo serde) throws AlreadyExistsException, MetaException {
+ boolean committed = false;
+ try {
+ openTransaction();
+ if (getMSerDeInfo(serde.getName()) != null) {
+ throw new AlreadyExistsException("Serde with name " + serde.getName() + " already exists");
+ }
+ MSerDeInfo mSerde = convertToMSerDeInfo(serde);
+ pm.makePersistent(mSerde);
+ committed = commitTransaction();
+ } finally {
+ if (!committed) rollbackTransaction();
+ }
+
+ }
+
+ private MISchema convertToMISchema(ISchema schema) throws NoSuchObjectException {
+ return new MISchema(schema.getSchemaType().getValue(),
+ normalizeIdentifier(schema.getName()),
+ getMDatabase(schema.getDbName()),
+ schema.getCompatibility().getValue(),
+ schema.getValidationLevel().getValue(),
+ schema.isCanEvolve(),
+ schema.isSetSchemaGroup() ? schema.getSchemaGroup() : null,
+ schema.isSetDescription() ? schema.getDescription() : null);
+ }
+
+ private ISchema convertToISchema(MISchema mSchema) {
+ if (mSchema == null) return null;
+ ISchema schema = new ISchema(SchemaType.findByValue(mSchema.getSchemaType()),
+ mSchema.getName(),
+ mSchema.getDb().getName(),
+ SchemaCompatibility.findByValue(mSchema.getCompatibility()),
+ SchemaValidation.findByValue(mSchema.getValidationLevel()),
+ mSchema.getCanEvolve());
+ if (mSchema.getDescription() != null) schema.setDescription(mSchema.getDescription());
+ if (mSchema.getSchemaGroup() != null) schema.setSchemaGroup(mSchema.getSchemaGroup());
+ return schema;
+ }
+
+ private MSchemaVersion convertToMSchemaVersion(SchemaVersion schemaVersion) throws MetaException {
+ return new MSchemaVersion(getMISchema(normalizeIdentifier(schemaVersion.getSchema().getDbName()),
+ normalizeIdentifier(schemaVersion.getSchema().getSchemaName())),
+ schemaVersion.getVersion(),
+ schemaVersion.getCreatedAt(),
+ createNewMColumnDescriptor(convertToMFieldSchemas(schemaVersion.getCols())),
+ schemaVersion.isSetState() ? schemaVersion.getState().getValue() : 0,
+ schemaVersion.isSetDescription() ? schemaVersion.getDescription() : null,
+ schemaVersion.isSetSchemaText() ? schemaVersion.getSchemaText() : null,
+ schemaVersion.isSetFingerprint() ? schemaVersion.getFingerprint() : null,
+ schemaVersion.isSetName() ? schemaVersion.getName() : null,
+ schemaVersion.isSetSerDe() ? convertToMSerDeInfo(schemaVersion.getSerDe()) : null);
+ }
+
+ private SchemaVersion convertToSchemaVersion(MSchemaVersion mSchemaVersion) throws MetaException {
+ if (mSchemaVersion == null) return null;
+ SchemaVersion schemaVersion = new SchemaVersion(
+ new ISchemaName(mSchemaVersion.getiSchema().getDb().getName(),
+ mSchemaVersion.getiSchema().getName()),
+ mSchemaVersion.getVersion(),
+ mSchemaVersion.getCreatedAt(),
+ convertToFieldSchemas(mSchemaVersion.getCols().getCols()));
+ if (mSchemaVersion.getState() > 0) schemaVersion.setState(SchemaVersionState.findByValue(mSchemaVersion.getState()));
+ if (mSchemaVersion.getDescription() != null) schemaVersion.setDescription(mSchemaVersion.getDescription());
+ if (mSchemaVersion.getSchemaText() != null) schemaVersion.setSchemaText(mSchemaVersion.getSchemaText());
+ if (mSchemaVersion.getFingerprint() != null) schemaVersion.setFingerprint(mSchemaVersion.getFingerprint());
+ if (mSchemaVersion.getName() != null) schemaVersion.setName(mSchemaVersion.getName());
+ if (mSchemaVersion.getSerDe() != null) schemaVersion.setSerDe(convertToSerDeInfo(mSchemaVersion.getSerDe()));
+ return schemaVersion;
+ }
+
/**
* This is a cleanup method which is used to rollback a active transaction
* if the success flag is false and close the associated Query object. This method is used
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java
index 40a7497..b079f8b 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/RawStore.java
@@ -18,7 +18,10 @@
package org.apache.hadoop.hive.metastore;
+import org.apache.hadoop.hive.metastore.api.AlterISchemaRequest;
import org.apache.hadoop.hive.metastore.api.CreationMetadata;
+import org.apache.hadoop.hive.metastore.api.ISchemaName;
+import org.apache.hadoop.hive.metastore.api.SchemaVersionDescriptor;
import org.apache.hadoop.hive.metastore.api.WMFullResourcePlan;
import java.lang.annotation.ElementType;
@@ -40,6 +43,7 @@ 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.HiveObjectPrivilege;
+import org.apache.hadoop.hive.metastore.api.ISchema;
import org.apache.hadoop.hive.metastore.api.InvalidInputException;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
@@ -69,6 +73,8 @@ import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint;
import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
import org.apache.hadoop.hive.metastore.api.SQLUniqueConstraint;
+import org.apache.hadoop.hive.metastore.api.SchemaVersion;
+import org.apache.hadoop.hive.metastore.api.SerDeInfo;
import org.apache.hadoop.hive.metastore.api.Table;
import org.apache.hadoop.hive.metastore.api.TableMeta;
import org.apache.hadoop.hive.metastore.api.Type;
@@ -805,4 +811,133 @@ public interface RawStore extends Configurable {
void dropWMTriggerToPoolMapping(String resourcePlanName, String triggerName, String poolPath)
throws NoSuchObjectException, InvalidOperationException, MetaException;
+
+ /**
+ * Create a new ISchema.
+ * @param schema schema to create
+ * @throws AlreadyExistsException there's already a schema with this name
+ * @throws MetaException general database exception
+ */
+ void createISchema(ISchema schema) throws AlreadyExistsException, MetaException,
+ NoSuchObjectException;
+
+ /**
+ * Alter an existing ISchema. This assumes the caller has already checked that such a schema
+ * exists.
+ * @param schemaName name of the schema
+ * @param newSchema new schema object
+ * @throws NoSuchObjectException no function with this name exists
+ * @throws MetaException general database exception
+ */
+ void alterISchema(ISchemaName schemaName, ISchema newSchema) throws NoSuchObjectException, MetaException;
+
+ /**
+ * Get an ISchema by name.
+ * @param schemaName schema descriptor
+ * @return ISchema
+ * @throws MetaException general database exception
+ */
+ ISchema getISchema(ISchemaName schemaName) throws MetaException;
+
+ /**
+ * Drop an ISchema. This does not check whether there are valid versions of the schema in
+ * existence, it assumes the caller has already done that.
+ * @param schemaName schema descriptor
+ * @throws NoSuchObjectException no schema of this name exists
+ * @throws MetaException general database exception
+ */
+ void dropISchema(ISchemaName schemaName) throws NoSuchObjectException, MetaException;
+
+ /**
+ * Create a new version of an existing schema.
+ * @param schemaVersion version number
+ * @throws AlreadyExistsException a version of the schema with the same version number already
+ * exists.
+ * @throws InvalidObjectException the passed in SchemaVersion object has problems.
+ * @throws NoSuchObjectException no schema with the passed in name exists.
+ * @throws MetaException general database exception
+ */
+ void addSchemaVersion(SchemaVersion schemaVersion)
+ throws AlreadyExistsException, InvalidObjectException, NoSuchObjectException, MetaException;
+
+ /**
+ * Alter a schema version. Note that the Thrift interface only supports changing the serde
+ * mapping and states. This method does not guarantee it will check anymore than that. This
+ * method does not understand the state transitions and just assumes that the new state it is
+ * passed is reasonable.
+ * @param version version descriptor for the schema
+ * @param newVersion altered SchemaVersion
+ * @throws NoSuchObjectException no such version of the named schema exists
+ * @throws MetaException general database exception
+ */
+ void alterSchemaVersion(SchemaVersionDescriptor version, SchemaVersion newVersion)
+ throws NoSuchObjectException, MetaException;
+
+ /**
+ * Get a specific schema version.
+ * @param version version descriptor for the schema
+ * @return the SchemaVersion
+ * @throws MetaException general database exception
+ */
+ SchemaVersion getSchemaVersion(SchemaVersionDescriptor version) throws MetaException;
+
+ /**
+ * Get the latest version of a schema.
+ * @param schemaName name of the schema
+ * @return latest version of the schema
+ * @throws MetaException general database exception
+ */
+ SchemaVersion getLatestSchemaVersion(ISchemaName schemaName) throws MetaException;
+
+ /**
+ * Get all of the versions of a schema
+ * @param schemaName name of the schema
+ * @return all versions of the schema
+ * @throws MetaException general database exception
+ */
+ List<SchemaVersion> getAllSchemaVersion(ISchemaName schemaName) throws MetaException;
+
+ /**
+ * Find all SchemaVersion objects that match a query. The query will select all SchemaVersions
+ * that are equal to all of the non-null passed in arguments. That is, if arguments
+ * colName='name', colNamespace=null, type='string' are passed in, then all schemas that have
+ * a column with colName 'name' and type 'string' will be returned.
+ * @param colName column name. Null is ok, which will cause this field to not be used in the
+ * query.
+ * @param colNamespace column namespace. Null is ok, which will cause this field to not be
+ * used in the query.
+ * @param type column type. Null is ok, which will cause this field to not be used in the
+ * query.
+ * @return List of all SchemaVersions that match. Note that there is no expectation that these
+ * SchemaVersions derive from the same ISchema. The list will be empty if there are no
+ * matching SchemaVersions.
+ * @throws MetaException general database exception
+ */
+ List<SchemaVersion> getSchemaVersionsByColumns(String colName, String colNamespace, String type)
+ throws MetaException;
+
+ /**
+ * Drop a version of the schema.
+ * @param version version descriptor for the schema
+ * @throws NoSuchObjectException no such version of the named schema exists
+ * @throws MetaException general database exception
+ */
+ void dropSchemaVersion(SchemaVersionDescriptor version) throws NoSuchObjectException, MetaException;
+
+ /**
+ * Get serde information
+ * @param serDeName name of the SerDe
+ * @return the SerDe, or null if there is no such serde
+ * @throws NoSuchObjectException no serde with this name exists
+ * @throws MetaException general database exception
+ */
+ SerDeInfo getSerDeInfo(String serDeName) throws NoSuchObjectException, MetaException;
+
+ /**
+ * Add a serde
+ * @param serde serde to add
+ * @throws AlreadyExistsException a serde of this name already exists
+ * @throws MetaException general database exception
+ */
+ void addSerde(SerDeInfo serde) throws AlreadyExistsException, MetaException;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java
index f58ba04..d28b196 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/cache/CachedStore.java
@@ -18,6 +18,8 @@
package org.apache.hadoop.hive.metastore.cache;
import org.apache.hadoop.hive.metastore.api.CreationMetadata;
+import org.apache.hadoop.hive.metastore.api.ISchemaName;
+import org.apache.hadoop.hive.metastore.api.SchemaVersionDescriptor;
import org.apache.hadoop.hive.metastore.api.WMFullResourcePlan;
import java.nio.ByteBuffer;
@@ -59,6 +61,7 @@ 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.HiveObjectPrivilege;
+import org.apache.hadoop.hive.metastore.api.ISchema;
import org.apache.hadoop.hive.metastore.api.InvalidInputException;
import org.apache.hadoop.hive.metastore.api.InvalidObjectException;
import org.apache.hadoop.hive.metastore.api.InvalidOperationException;
@@ -91,6 +94,8 @@ import org.apache.hadoop.hive.metastore.api.SQLForeignKey;
import org.apache.hadoop.hive.metastore.api.SQLNotNullConstraint;
import org.apache.hadoop.hive.metastore.api.SQLPrimaryKey;
import org.apache.hadoop.hive.metastore.api.SQLUniqueConstraint;
+import org.apache.hadoop.hive.metastore.api.SchemaVersion;
+import org.apache.hadoop.hive.metastore.api.SerDeInfo;
import org.apache.hadoop.hive.metastore.api.StorageDescriptor;
import org.apache.hadoop.hive.metastore.api.Table;
import org.apache.hadoop.hive.metastore.api.TableMeta;
@@ -2500,6 +2505,78 @@ public class CachedStore implements RawStore, Configurable {
return rawStore.getPartitionColStatsForDatabase(dbName);
}
+ // TODO - not clear if we should cache these or not. For now, don't bother
+ @Override
+ public void createISchema(ISchema schema)
+ throws AlreadyExistsException, NoSuchObjectException, MetaException {
+ rawStore.createISchema(schema);
+ }
+
+ @Override
+ public void alterISchema(ISchemaName schemaName, ISchema newSchema)
+ throws NoSuchObjectException, MetaException {
+ rawStore.alterISchema(schemaName, newSchema);
+ }
+
+ @Override
+ public ISchema getISchema(ISchemaName schemaName) throws MetaException {
+ return rawStore.getISchema(schemaName);
+ }
+
+ @Override
+ public void dropISchema(ISchemaName schemaName) throws NoSuchObjectException, MetaException {
+ rawStore.dropISchema(schemaName);
+ }
+
+ @Override
+ public void addSchemaVersion(SchemaVersion schemaVersion) throws
+ AlreadyExistsException, InvalidObjectException, NoSuchObjectException, MetaException {
+ rawStore.addSchemaVersion(schemaVersion);
+ }
+
+ @Override
+ public void alterSchemaVersion(SchemaVersionDescriptor version, SchemaVersion newVersion) throws
+ NoSuchObjectException, MetaException {
+ rawStore.alterSchemaVersion(version, newVersion);
+ }
+
+ @Override
+ public SchemaVersion getSchemaVersion(SchemaVersionDescriptor version) throws MetaException {
+ return rawStore.getSchemaVersion(version);
+ }
+
+ @Override
+ public SchemaVersion getLatestSchemaVersion(ISchemaName schemaName) throws MetaException {
+ return rawStore.getLatestSchemaVersion(schemaName);
+ }
+
+ @Override
+ public List<SchemaVersion> getAllSchemaVersion(ISchemaName schemaName) throws MetaException {
+ return rawStore.getAllSchemaVersion(schemaName);
+ }
+
+ @Override
+ public List<SchemaVersion> getSchemaVersionsByColumns(String colName, String colNamespace,
+ String type) throws MetaException {
+ return rawStore.getSchemaVersionsByColumns(colName, colNamespace, type);
+ }
+
+ @Override
+ public void dropSchemaVersion(SchemaVersionDescriptor version) throws NoSuchObjectException,
+ MetaException {
+ rawStore.dropSchemaVersion(version);
+ }
+
+ @Override
+ public SerDeInfo getSerDeInfo(String serDeName) throws NoSuchObjectException, MetaException {
+ return rawStore.getSerDeInfo(serDeName);
+ }
+
+ @Override
+ public void addSerde(SerDeInfo serde) throws AlreadyExistsException, MetaException {
+ rawStore.addSerde(serde);
+ }
+
public RawStore getRawStore() {
return rawStore;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/DatabaseBuilder.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/DatabaseBuilder.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/DatabaseBuilder.java
index 7627d89..01693ec 100644
--- a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/DatabaseBuilder.java
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/DatabaseBuilder.java
@@ -73,7 +73,7 @@ public class DatabaseBuilder {
return this;
}
- public Database build() throws TException {
+ public Database build() throws MetaException {
if (name == null) throw new MetaException("You must name the database");
Database db = new Database(name, description, location, params);
try {
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/ISchemaBuilder.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/ISchemaBuilder.java b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/ISchemaBuilder.java
new file mode 100644
index 0000000..32a84ac
--- /dev/null
+++ b/standalone-metastore/src/main/java/org/apache/hadoop/hive/metastore/client/builder/ISchemaBuilder.java
@@ -0,0 +1,94 @@
+/*
+ * 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.client.builder;
+
+import org.apache.hadoop.hive.metastore.Warehouse;
+import org.apache.hadoop.hive.metastore.api.ISchema;
+import org.apache.hadoop.hive.metastore.api.MetaException;
+import org.apache.hadoop.hive.metastore.api.SchemaCompatibility;
+import org.apache.hadoop.hive.metastore.api.SchemaType;
+import org.apache.hadoop.hive.metastore.api.SchemaValidation;
+
+public class ISchemaBuilder {
+ private SchemaType schemaType; // required
+ private String name; // required
+ private String dbName; // required
+ private SchemaCompatibility compatibility; // required
+ private SchemaValidation validationLevel; // required
+ private boolean canEvolve; // required
+ private String schemaGroup; // optional
+ private String description; // optional
+
+ public ISchemaBuilder() {
+ compatibility = SchemaCompatibility.BACKWARD;
+ validationLevel = SchemaValidation.ALL;
+ canEvolve = true;
+ dbName = Warehouse.DEFAULT_DATABASE_NAME;
+ }
+
+ public ISchemaBuilder setSchemaType(SchemaType schemaType) {
+ this.schemaType = schemaType;
+ return this;
+ }
+
+ public ISchemaBuilder setName(String name) {
+ this.name = name;
+ return this;
+ }
+
+ public ISchemaBuilder setDbName(String dbName) {
+ this.dbName = dbName;
+ return this;
+ }
+
+ public ISchemaBuilder setCompatibility(SchemaCompatibility compatibility) {
+ this.compatibility = compatibility;
+ return this;
+ }
+
+ public ISchemaBuilder setValidationLevel(SchemaValidation validationLevel) {
+ this.validationLevel = validationLevel;
+ return this;
+ }
+
+ public ISchemaBuilder setCanEvolve(boolean canEvolve) {
+ this.canEvolve = canEvolve;
+ return this;
+ }
+
+ public ISchemaBuilder setSchemaGroup(String schemaGroup) {
+ this.schemaGroup = schemaGroup;
+ return this;
+ }
+
+ public ISchemaBuilder setDescription(String description) {
+ this.description = description;
+ return this;
+ }
+
+ public ISchema build() throws MetaException {
+ if (schemaType == null || name == null) {
+ throw new MetaException("You must provide a schemaType and name");
+ }
+ ISchema iSchema =
+ new ISchema(schemaType, name, dbName, compatibility, validationLevel, canEvolve);
+ if (schemaGroup != null) iSchema.setSchemaGroup(schemaGroup);
+ if (description != null) iSchema.setDescription(description);
+ return iSchema;
+ }
+}