[13/18] hive git commit: HIVE-17990 Add Thrift and DB storage for Schema Registry objects (Alan Gates, reviewed by Thejas Nair)

[ga...@apache.org]

http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
index cee1382..ef8b694 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
@@ -132,6 +132,59 @@ struct EventRequestType {
 
 extern const std::map<int, const char*> _EventRequestType_VALUES_TO_NAMES;
 
+struct SerdeType {
+  enum type {
+    HIVE = 1,
+    SCHEMA_REGISTRY = 2
+  };
+};
+
+extern const std::map<int, const char*> _SerdeType_VALUES_TO_NAMES;
+
+struct SchemaType {
+  enum type {
+    HIVE = 1,
+    AVRO = 2
+  };
+};
+
+extern const std::map<int, const char*> _SchemaType_VALUES_TO_NAMES;
+
+struct SchemaCompatibility {
+  enum type {
+    NONE = 1,
+    BACKWARD = 2,
+    FORWARD = 3,
+    BOTH = 4
+  };
+};
+
+extern const std::map<int, const char*> _SchemaCompatibility_VALUES_TO_NAMES;
+
+struct SchemaValidation {
+  enum type {
+    LATEST = 1,
+    ALL = 2
+  };
+};
+
+extern const std::map<int, const char*> _SchemaValidation_VALUES_TO_NAMES;
+
+struct SchemaVersionState {
+  enum type {
+    INITIATED = 1,
+    START_REVIEW = 2,
+    CHANGES_REQUIRED = 3,
+    REVIEWED = 4,
+    ENABLED = 5,
+    DISABLED = 6,
+    ARCHIVED = 7,
+    DELETED = 8
+  };
+};
+
+extern const std::map<int, const char*> _SchemaVersionState_VALUES_TO_NAMES;
+
 struct FunctionType {
   enum type {
     JAVA = 1
@@ -566,6 +619,26 @@ class WMCreateOrDropTriggerToPoolMappingRequest;
 
 class WMCreateOrDropTriggerToPoolMappingResponse;
 
+class ISchema;
+
+class ISchemaName;
+
+class AlterISchemaRequest;
+
+class SchemaVersion;
+
+class SchemaVersionDescriptor;
+
+class FindSchemasByColsRqst;
+
+class FindSchemasByColsResp;
+
+class MapSchemaVersionToSerdeRequest;
+
+class SetSchemaVersionStateRequest;
+
+class GetSerdeRequest;
+
 class MetaException;
 
 class UnknownTableException;
@@ -2192,10 +2265,14 @@ inline std::ostream& operator<<(std::ostream& out, const Database& obj)
 }
 
 typedef struct _SerDeInfo__isset {
-  _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false) {}
+  _SerDeInfo__isset() : name(false), serializationLib(false), parameters(false), description(false), serializerClass(false), deserializerClass(false), serdeType(false) {}
   bool name :1;
   bool serializationLib :1;
   bool parameters :1;
+  bool description :1;
+  bool serializerClass :1;
+  bool deserializerClass :1;
+  bool serdeType :1;
 } _SerDeInfo__isset;
 
 class SerDeInfo {
@@ -2203,13 +2280,17 @@ class SerDeInfo {
 
   SerDeInfo(const SerDeInfo&);
   SerDeInfo& operator=(const SerDeInfo&);
-  SerDeInfo() : name(), serializationLib() {
+  SerDeInfo() : name(), serializationLib(), description(), serializerClass(), deserializerClass(), serdeType((SerdeType::type)0) {
   }
 
   virtual ~SerDeInfo() throw();
   std::string name;
   std::string serializationLib;
   std::map<std::string, std::string>  parameters;
+  std::string description;
+  std::string serializerClass;
+  std::string deserializerClass;
+  SerdeType::type serdeType;
 
   _SerDeInfo__isset __isset;
 
@@ -2219,6 +2300,14 @@ class SerDeInfo {
 
   void __set_parameters(const std::map<std::string, std::string> & val);
 
+  void __set_description(const std::string& val);
+
+  void __set_serializerClass(const std::string& val);
+
+  void __set_deserializerClass(const std::string& val);
+
+  void __set_serdeType(const SerdeType::type val);
+
   bool operator == (const SerDeInfo & rhs) const
   {
     if (!(name == rhs.name))
@@ -2227,6 +2316,22 @@ class SerDeInfo {
       return false;
     if (!(parameters == rhs.parameters))
       return false;
+    if (__isset.description != rhs.__isset.description)
+      return false;
+    else if (__isset.description && !(description == rhs.description))
+      return false;
+    if (__isset.serializerClass != rhs.__isset.serializerClass)
+      return false;
+    else if (__isset.serializerClass && !(serializerClass == rhs.serializerClass))
+      return false;
+    if (__isset.deserializerClass != rhs.__isset.deserializerClass)
+      return false;
+    else if (__isset.deserializerClass && !(deserializerClass == rhs.deserializerClass))
+      return false;
+    if (__isset.serdeType != rhs.__isset.serdeType)
+      return false;
+    else if (__isset.serdeType && !(serdeType == rhs.serdeType))
+      return false;
     return true;
   }
   bool operator != (const SerDeInfo &rhs) const {
@@ -11328,6 +11433,626 @@ inline std::ostream& operator<<(std::ostream& out, const WMCreateOrDropTriggerTo
   return out;
 }
 
+typedef struct _ISchema__isset {
+  _ISchema__isset() : schemaType(false), name(false), dbName(false), compatibility(false), validationLevel(false), canEvolve(false), schemaGroup(false), description(false) {}
+  bool schemaType :1;
+  bool name :1;
+  bool dbName :1;
+  bool compatibility :1;
+  bool validationLevel :1;
+  bool canEvolve :1;
+  bool schemaGroup :1;
+  bool description :1;
+} _ISchema__isset;
+
+class ISchema {
+ public:
+
+  ISchema(const ISchema&);
+  ISchema& operator=(const ISchema&);
+  ISchema() : schemaType((SchemaType::type)0), name(), dbName(), compatibility((SchemaCompatibility::type)0), validationLevel((SchemaValidation::type)0), canEvolve(0), schemaGroup(), description() {
+  }
+
+  virtual ~ISchema() throw();
+  SchemaType::type schemaType;
+  std::string name;
+  std::string dbName;
+  SchemaCompatibility::type compatibility;
+  SchemaValidation::type validationLevel;
+  bool canEvolve;
+  std::string schemaGroup;
+  std::string description;
+
+  _ISchema__isset __isset;
+
+  void __set_schemaType(const SchemaType::type val);
+
+  void __set_name(const std::string& val);
+
+  void __set_dbName(const std::string& val);
+
+  void __set_compatibility(const SchemaCompatibility::type val);
+
+  void __set_validationLevel(const SchemaValidation::type val);
+
+  void __set_canEvolve(const bool val);
+
+  void __set_schemaGroup(const std::string& val);
+
+  void __set_description(const std::string& val);
+
+  bool operator == (const ISchema & rhs) const
+  {
+    if (!(schemaType == rhs.schemaType))
+      return false;
+    if (!(name == rhs.name))
+      return false;
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(compatibility == rhs.compatibility))
+      return false;
+    if (!(validationLevel == rhs.validationLevel))
+      return false;
+    if (!(canEvolve == rhs.canEvolve))
+      return false;
+    if (__isset.schemaGroup != rhs.__isset.schemaGroup)
+      return false;
+    else if (__isset.schemaGroup && !(schemaGroup == rhs.schemaGroup))
+      return false;
+    if (__isset.description != rhs.__isset.description)
+      return false;
+    else if (__isset.description && !(description == rhs.description))
+      return false;
+    return true;
+  }
+  bool operator != (const ISchema &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ISchema & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(ISchema &a, ISchema &b);
+
+inline std::ostream& operator<<(std::ostream& out, const ISchema& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _ISchemaName__isset {
+  _ISchemaName__isset() : dbName(false), schemaName(false) {}
+  bool dbName :1;
+  bool schemaName :1;
+} _ISchemaName__isset;
+
+class ISchemaName {
+ public:
+
+  ISchemaName(const ISchemaName&);
+  ISchemaName& operator=(const ISchemaName&);
+  ISchemaName() : dbName(), schemaName() {
+  }
+
+  virtual ~ISchemaName() throw();
+  std::string dbName;
+  std::string schemaName;
+
+  _ISchemaName__isset __isset;
+
+  void __set_dbName(const std::string& val);
+
+  void __set_schemaName(const std::string& val);
+
+  bool operator == (const ISchemaName & rhs) const
+  {
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(schemaName == rhs.schemaName))
+      return false;
+    return true;
+  }
+  bool operator != (const ISchemaName &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ISchemaName & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(ISchemaName &a, ISchemaName &b);
+
+inline std::ostream& operator<<(std::ostream& out, const ISchemaName& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _AlterISchemaRequest__isset {
+  _AlterISchemaRequest__isset() : name(false), newSchema(false) {}
+  bool name :1;
+  bool newSchema :1;
+} _AlterISchemaRequest__isset;
+
+class AlterISchemaRequest {
+ public:
+
+  AlterISchemaRequest(const AlterISchemaRequest&);
+  AlterISchemaRequest& operator=(const AlterISchemaRequest&);
+  AlterISchemaRequest() {
+  }
+
+  virtual ~AlterISchemaRequest() throw();
+  ISchemaName name;
+  ISchema newSchema;
+
+  _AlterISchemaRequest__isset __isset;
+
+  void __set_name(const ISchemaName& val);
+
+  void __set_newSchema(const ISchema& val);
+
+  bool operator == (const AlterISchemaRequest & rhs) const
+  {
+    if (!(name == rhs.name))
+      return false;
+    if (!(newSchema == rhs.newSchema))
+      return false;
+    return true;
+  }
+  bool operator != (const AlterISchemaRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const AlterISchemaRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(AlterISchemaRequest &a, AlterISchemaRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const AlterISchemaRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _SchemaVersion__isset {
+  _SchemaVersion__isset() : schema(false), version(false), createdAt(false), cols(false), state(false), description(false), schemaText(false), fingerprint(false), name(false), serDe(false) {}
+  bool schema :1;
+  bool version :1;
+  bool createdAt :1;
+  bool cols :1;
+  bool state :1;
+  bool description :1;
+  bool schemaText :1;
+  bool fingerprint :1;
+  bool name :1;
+  bool serDe :1;
+} _SchemaVersion__isset;
+
+class SchemaVersion {
+ public:
+
+  SchemaVersion(const SchemaVersion&);
+  SchemaVersion& operator=(const SchemaVersion&);
+  SchemaVersion() : version(0), createdAt(0), state((SchemaVersionState::type)0), description(), schemaText(), fingerprint(), name() {
+  }
+
+  virtual ~SchemaVersion() throw();
+  ISchemaName schema;
+  int32_t version;
+  int64_t createdAt;
+  std::vector<FieldSchema>  cols;
+  SchemaVersionState::type state;
+  std::string description;
+  std::string schemaText;
+  std::string fingerprint;
+  std::string name;
+  SerDeInfo serDe;
+
+  _SchemaVersion__isset __isset;
+
+  void __set_schema(const ISchemaName& val);
+
+  void __set_version(const int32_t val);
+
+  void __set_createdAt(const int64_t val);
+
+  void __set_cols(const std::vector<FieldSchema> & val);
+
+  void __set_state(const SchemaVersionState::type val);
+
+  void __set_description(const std::string& val);
+
+  void __set_schemaText(const std::string& val);
+
+  void __set_fingerprint(const std::string& val);
+
+  void __set_name(const std::string& val);
+
+  void __set_serDe(const SerDeInfo& val);
+
+  bool operator == (const SchemaVersion & rhs) const
+  {
+    if (!(schema == rhs.schema))
+      return false;
+    if (!(version == rhs.version))
+      return false;
+    if (!(createdAt == rhs.createdAt))
+      return false;
+    if (!(cols == rhs.cols))
+      return false;
+    if (__isset.state != rhs.__isset.state)
+      return false;
+    else if (__isset.state && !(state == rhs.state))
+      return false;
+    if (__isset.description != rhs.__isset.description)
+      return false;
+    else if (__isset.description && !(description == rhs.description))
+      return false;
+    if (__isset.schemaText != rhs.__isset.schemaText)
+      return false;
+    else if (__isset.schemaText && !(schemaText == rhs.schemaText))
+      return false;
+    if (__isset.fingerprint != rhs.__isset.fingerprint)
+      return false;
+    else if (__isset.fingerprint && !(fingerprint == rhs.fingerprint))
+      return false;
+    if (__isset.name != rhs.__isset.name)
+      return false;
+    else if (__isset.name && !(name == rhs.name))
+      return false;
+    if (__isset.serDe != rhs.__isset.serDe)
+      return false;
+    else if (__isset.serDe && !(serDe == rhs.serDe))
+      return false;
+    return true;
+  }
+  bool operator != (const SchemaVersion &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SchemaVersion & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(SchemaVersion &a, SchemaVersion &b);
+
+inline std::ostream& operator<<(std::ostream& out, const SchemaVersion& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _SchemaVersionDescriptor__isset {
+  _SchemaVersionDescriptor__isset() : schema(false), version(false) {}
+  bool schema :1;
+  bool version :1;
+} _SchemaVersionDescriptor__isset;
+
+class SchemaVersionDescriptor {
+ public:
+
+  SchemaVersionDescriptor(const SchemaVersionDescriptor&);
+  SchemaVersionDescriptor& operator=(const SchemaVersionDescriptor&);
+  SchemaVersionDescriptor() : version(0) {
+  }
+
+  virtual ~SchemaVersionDescriptor() throw();
+  ISchemaName schema;
+  int32_t version;
+
+  _SchemaVersionDescriptor__isset __isset;
+
+  void __set_schema(const ISchemaName& val);
+
+  void __set_version(const int32_t val);
+
+  bool operator == (const SchemaVersionDescriptor & rhs) const
+  {
+    if (!(schema == rhs.schema))
+      return false;
+    if (!(version == rhs.version))
+      return false;
+    return true;
+  }
+  bool operator != (const SchemaVersionDescriptor &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SchemaVersionDescriptor & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(SchemaVersionDescriptor &a, SchemaVersionDescriptor &b);
+
+inline std::ostream& operator<<(std::ostream& out, const SchemaVersionDescriptor& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _FindSchemasByColsRqst__isset {
+  _FindSchemasByColsRqst__isset() : colName(false), colNamespace(false), type(false) {}
+  bool colName :1;
+  bool colNamespace :1;
+  bool type :1;
+} _FindSchemasByColsRqst__isset;
+
+class FindSchemasByColsRqst {
+ public:
+
+  FindSchemasByColsRqst(const FindSchemasByColsRqst&);
+  FindSchemasByColsRqst& operator=(const FindSchemasByColsRqst&);
+  FindSchemasByColsRqst() : colName(), colNamespace(), type() {
+  }
+
+  virtual ~FindSchemasByColsRqst() throw();
+  std::string colName;
+  std::string colNamespace;
+  std::string type;
+
+  _FindSchemasByColsRqst__isset __isset;
+
+  void __set_colName(const std::string& val);
+
+  void __set_colNamespace(const std::string& val);
+
+  void __set_type(const std::string& val);
+
+  bool operator == (const FindSchemasByColsRqst & rhs) const
+  {
+    if (__isset.colName != rhs.__isset.colName)
+      return false;
+    else if (__isset.colName && !(colName == rhs.colName))
+      return false;
+    if (__isset.colNamespace != rhs.__isset.colNamespace)
+      return false;
+    else if (__isset.colNamespace && !(colNamespace == rhs.colNamespace))
+      return false;
+    if (__isset.type != rhs.__isset.type)
+      return false;
+    else if (__isset.type && !(type == rhs.type))
+      return false;
+    return true;
+  }
+  bool operator != (const FindSchemasByColsRqst &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const FindSchemasByColsRqst & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(FindSchemasByColsRqst &a, FindSchemasByColsRqst &b);
+
+inline std::ostream& operator<<(std::ostream& out, const FindSchemasByColsRqst& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _FindSchemasByColsResp__isset {
+  _FindSchemasByColsResp__isset() : schemaVersions(false) {}
+  bool schemaVersions :1;
+} _FindSchemasByColsResp__isset;
+
+class FindSchemasByColsResp {
+ public:
+
+  FindSchemasByColsResp(const FindSchemasByColsResp&);
+  FindSchemasByColsResp& operator=(const FindSchemasByColsResp&);
+  FindSchemasByColsResp() {
+  }
+
+  virtual ~FindSchemasByColsResp() throw();
+  std::vector<SchemaVersionDescriptor>  schemaVersions;
+
+  _FindSchemasByColsResp__isset __isset;
+
+  void __set_schemaVersions(const std::vector<SchemaVersionDescriptor> & val);
+
+  bool operator == (const FindSchemasByColsResp & rhs) const
+  {
+    if (!(schemaVersions == rhs.schemaVersions))
+      return false;
+    return true;
+  }
+  bool operator != (const FindSchemasByColsResp &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const FindSchemasByColsResp & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(FindSchemasByColsResp &a, FindSchemasByColsResp &b);
+
+inline std::ostream& operator<<(std::ostream& out, const FindSchemasByColsResp& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _MapSchemaVersionToSerdeRequest__isset {
+  _MapSchemaVersionToSerdeRequest__isset() : schemaVersion(false), serdeName(false) {}
+  bool schemaVersion :1;
+  bool serdeName :1;
+} _MapSchemaVersionToSerdeRequest__isset;
+
+class MapSchemaVersionToSerdeRequest {
+ public:
+
+  MapSchemaVersionToSerdeRequest(const MapSchemaVersionToSerdeRequest&);
+  MapSchemaVersionToSerdeRequest& operator=(const MapSchemaVersionToSerdeRequest&);
+  MapSchemaVersionToSerdeRequest() : serdeName() {
+  }
+
+  virtual ~MapSchemaVersionToSerdeRequest() throw();
+  SchemaVersionDescriptor schemaVersion;
+  std::string serdeName;
+
+  _MapSchemaVersionToSerdeRequest__isset __isset;
+
+  void __set_schemaVersion(const SchemaVersionDescriptor& val);
+
+  void __set_serdeName(const std::string& val);
+
+  bool operator == (const MapSchemaVersionToSerdeRequest & rhs) const
+  {
+    if (!(schemaVersion == rhs.schemaVersion))
+      return false;
+    if (!(serdeName == rhs.serdeName))
+      return false;
+    return true;
+  }
+  bool operator != (const MapSchemaVersionToSerdeRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const MapSchemaVersionToSerdeRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(MapSchemaVersionToSerdeRequest &a, MapSchemaVersionToSerdeRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const MapSchemaVersionToSerdeRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _SetSchemaVersionStateRequest__isset {
+  _SetSchemaVersionStateRequest__isset() : schemaVersion(false), state(false) {}
+  bool schemaVersion :1;
+  bool state :1;
+} _SetSchemaVersionStateRequest__isset;
+
+class SetSchemaVersionStateRequest {
+ public:
+
+  SetSchemaVersionStateRequest(const SetSchemaVersionStateRequest&);
+  SetSchemaVersionStateRequest& operator=(const SetSchemaVersionStateRequest&);
+  SetSchemaVersionStateRequest() : state((SchemaVersionState::type)0) {
+  }
+
+  virtual ~SetSchemaVersionStateRequest() throw();
+  SchemaVersionDescriptor schemaVersion;
+  SchemaVersionState::type state;
+
+  _SetSchemaVersionStateRequest__isset __isset;
+
+  void __set_schemaVersion(const SchemaVersionDescriptor& val);
+
+  void __set_state(const SchemaVersionState::type val);
+
+  bool operator == (const SetSchemaVersionStateRequest & rhs) const
+  {
+    if (!(schemaVersion == rhs.schemaVersion))
+      return false;
+    if (!(state == rhs.state))
+      return false;
+    return true;
+  }
+  bool operator != (const SetSchemaVersionStateRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SetSchemaVersionStateRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(SetSchemaVersionStateRequest &a, SetSchemaVersionStateRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const SetSchemaVersionStateRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+typedef struct _GetSerdeRequest__isset {
+  _GetSerdeRequest__isset() : serdeName(false) {}
+  bool serdeName :1;
+} _GetSerdeRequest__isset;
+
+class GetSerdeRequest {
+ public:
+
+  GetSerdeRequest(const GetSerdeRequest&);
+  GetSerdeRequest& operator=(const GetSerdeRequest&);
+  GetSerdeRequest() : serdeName() {
+  }
+
+  virtual ~GetSerdeRequest() throw();
+  std::string serdeName;
+
+  _GetSerdeRequest__isset __isset;
+
+  void __set_serdeName(const std::string& val);
+
+  bool operator == (const GetSerdeRequest & rhs) const
+  {
+    if (!(serdeName == rhs.serdeName))
+      return false;
+    return true;
+  }
+  bool operator != (const GetSerdeRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const GetSerdeRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(GetSerdeRequest &a, GetSerdeRequest &b);
+
+inline std::ostream& operator<<(std::ostream& out, const GetSerdeRequest& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
 typedef struct _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message :1;

http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterISchemaRequest.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterISchemaRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterISchemaRequest.java
new file mode 100644
index 0000000..c079fab
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/AlterISchemaRequest.java
@@ -0,0 +1,509 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class AlterISchemaRequest implements org.apache.thrift.TBase<AlterISchemaRequest, AlterISchemaRequest._Fields>, java.io.Serializable, Cloneable, Comparable<AlterISchemaRequest> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AlterISchemaRequest");
+
+  private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRUCT, (short)1);
+  private static final org.apache.thrift.protocol.TField NEW_SCHEMA_FIELD_DESC = new org.apache.thrift.protocol.TField("newSchema", org.apache.thrift.protocol.TType.STRUCT, (short)3);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new AlterISchemaRequestStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new AlterISchemaRequestTupleSchemeFactory());
+  }
+
+  private ISchemaName name; // required
+  private ISchema newSchema; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    NAME((short)1, "name"),
+    NEW_SCHEMA((short)3, "newSchema");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // NAME
+          return NAME;
+        case 3: // NEW_SCHEMA
+          return NEW_SCHEMA;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ISchemaName.class)));
+    tmpMap.put(_Fields.NEW_SCHEMA, new org.apache.thrift.meta_data.FieldMetaData("newSchema", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ISchema.class)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AlterISchemaRequest.class, metaDataMap);
+  }
+
+  public AlterISchemaRequest() {
+  }
+
+  public AlterISchemaRequest(
+    ISchemaName name,
+    ISchema newSchema)
+  {
+    this();
+    this.name = name;
+    this.newSchema = newSchema;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public AlterISchemaRequest(AlterISchemaRequest other) {
+    if (other.isSetName()) {
+      this.name = new ISchemaName(other.name);
+    }
+    if (other.isSetNewSchema()) {
+      this.newSchema = new ISchema(other.newSchema);
+    }
+  }
+
+  public AlterISchemaRequest deepCopy() {
+    return new AlterISchemaRequest(this);
+  }
+
+  @Override
+  public void clear() {
+    this.name = null;
+    this.newSchema = null;
+  }
+
+  public ISchemaName getName() {
+    return this.name;
+  }
+
+  public void setName(ISchemaName name) {
+    this.name = name;
+  }
+
+  public void unsetName() {
+    this.name = null;
+  }
+
+  /** Returns true if field name is set (has been assigned a value) and false otherwise */
+  public boolean isSetName() {
+    return this.name != null;
+  }
+
+  public void setNameIsSet(boolean value) {
+    if (!value) {
+      this.name = null;
+    }
+  }
+
+  public ISchema getNewSchema() {
+    return this.newSchema;
+  }
+
+  public void setNewSchema(ISchema newSchema) {
+    this.newSchema = newSchema;
+  }
+
+  public void unsetNewSchema() {
+    this.newSchema = null;
+  }
+
+  /** Returns true if field newSchema is set (has been assigned a value) and false otherwise */
+  public boolean isSetNewSchema() {
+    return this.newSchema != null;
+  }
+
+  public void setNewSchemaIsSet(boolean value) {
+    if (!value) {
+      this.newSchema = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case NAME:
+      if (value == null) {
+        unsetName();
+      } else {
+        setName((ISchemaName)value);
+      }
+      break;
+
+    case NEW_SCHEMA:
+      if (value == null) {
+        unsetNewSchema();
+      } else {
+        setNewSchema((ISchema)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case NAME:
+      return getName();
+
+    case NEW_SCHEMA:
+      return getNewSchema();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case NAME:
+      return isSetName();
+    case NEW_SCHEMA:
+      return isSetNewSchema();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof AlterISchemaRequest)
+      return this.equals((AlterISchemaRequest)that);
+    return false;
+  }
+
+  public boolean equals(AlterISchemaRequest that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_name = true && this.isSetName();
+    boolean that_present_name = true && that.isSetName();
+    if (this_present_name || that_present_name) {
+      if (!(this_present_name && that_present_name))
+        return false;
+      if (!this.name.equals(that.name))
+        return false;
+    }
+
+    boolean this_present_newSchema = true && this.isSetNewSchema();
+    boolean that_present_newSchema = true && that.isSetNewSchema();
+    if (this_present_newSchema || that_present_newSchema) {
+      if (!(this_present_newSchema && that_present_newSchema))
+        return false;
+      if (!this.newSchema.equals(that.newSchema))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_name = true && (isSetName());
+    list.add(present_name);
+    if (present_name)
+      list.add(name);
+
+    boolean present_newSchema = true && (isSetNewSchema());
+    list.add(present_newSchema);
+    if (present_newSchema)
+      list.add(newSchema);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(AlterISchemaRequest other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetNewSchema()).compareTo(other.isSetNewSchema());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetNewSchema()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.newSchema, other.newSchema);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("AlterISchemaRequest(");
+    boolean first = true;
+
+    sb.append("name:");
+    if (this.name == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.name);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("newSchema:");
+    if (this.newSchema == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.newSchema);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+    if (name != null) {
+      name.validate();
+    }
+    if (newSchema != null) {
+      newSchema.validate();
+    }
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class AlterISchemaRequestStandardSchemeFactory implements SchemeFactory {
+    public AlterISchemaRequestStandardScheme getScheme() {
+      return new AlterISchemaRequestStandardScheme();
+    }
+  }
+
+  private static class AlterISchemaRequestStandardScheme extends StandardScheme<AlterISchemaRequest> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, AlterISchemaRequest struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.name = new ISchemaName();
+              struct.name.read(iprot);
+              struct.setNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // NEW_SCHEMA
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
+              struct.newSchema = new ISchema();
+              struct.newSchema.read(iprot);
+              struct.setNewSchemaIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, AlterISchemaRequest struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.name != null) {
+        oprot.writeFieldBegin(NAME_FIELD_DESC);
+        struct.name.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      if (struct.newSchema != null) {
+        oprot.writeFieldBegin(NEW_SCHEMA_FIELD_DESC);
+        struct.newSchema.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class AlterISchemaRequestTupleSchemeFactory implements SchemeFactory {
+    public AlterISchemaRequestTupleScheme getScheme() {
+      return new AlterISchemaRequestTupleScheme();
+    }
+  }
+
+  private static class AlterISchemaRequestTupleScheme extends TupleScheme<AlterISchemaRequest> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, AlterISchemaRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetName()) {
+        optionals.set(0);
+      }
+      if (struct.isSetNewSchema()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetName()) {
+        struct.name.write(oprot);
+      }
+      if (struct.isSetNewSchema()) {
+        struct.newSchema.write(oprot);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, AlterISchemaRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.name = new ISchemaName();
+        struct.name.read(iprot);
+        struct.setNameIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.newSchema = new ISchema();
+        struct.newSchema.read(iprot);
+        struct.setNewSchemaIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsResp.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsResp.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsResp.java
new file mode 100644
index 0000000..01bc32d
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsResp.java
@@ -0,0 +1,449 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class FindSchemasByColsResp implements org.apache.thrift.TBase<FindSchemasByColsResp, FindSchemasByColsResp._Fields>, java.io.Serializable, Cloneable, Comparable<FindSchemasByColsResp> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FindSchemasByColsResp");
+
+  private static final org.apache.thrift.protocol.TField SCHEMA_VERSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("schemaVersions", org.apache.thrift.protocol.TType.LIST, (short)1);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new FindSchemasByColsRespStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new FindSchemasByColsRespTupleSchemeFactory());
+  }
+
+  private List<SchemaVersionDescriptor> schemaVersions; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    SCHEMA_VERSIONS((short)1, "schemaVersions");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // SCHEMA_VERSIONS
+          return SCHEMA_VERSIONS;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.SCHEMA_VERSIONS, new org.apache.thrift.meta_data.FieldMetaData("schemaVersions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
+            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, SchemaVersionDescriptor.class))));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FindSchemasByColsResp.class, metaDataMap);
+  }
+
+  public FindSchemasByColsResp() {
+  }
+
+  public FindSchemasByColsResp(
+    List<SchemaVersionDescriptor> schemaVersions)
+  {
+    this();
+    this.schemaVersions = schemaVersions;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public FindSchemasByColsResp(FindSchemasByColsResp other) {
+    if (other.isSetSchemaVersions()) {
+      List<SchemaVersionDescriptor> __this__schemaVersions = new ArrayList<SchemaVersionDescriptor>(other.schemaVersions.size());
+      for (SchemaVersionDescriptor other_element : other.schemaVersions) {
+        __this__schemaVersions.add(new SchemaVersionDescriptor(other_element));
+      }
+      this.schemaVersions = __this__schemaVersions;
+    }
+  }
+
+  public FindSchemasByColsResp deepCopy() {
+    return new FindSchemasByColsResp(this);
+  }
+
+  @Override
+  public void clear() {
+    this.schemaVersions = null;
+  }
+
+  public int getSchemaVersionsSize() {
+    return (this.schemaVersions == null) ? 0 : this.schemaVersions.size();
+  }
+
+  public java.util.Iterator<SchemaVersionDescriptor> getSchemaVersionsIterator() {
+    return (this.schemaVersions == null) ? null : this.schemaVersions.iterator();
+  }
+
+  public void addToSchemaVersions(SchemaVersionDescriptor elem) {
+    if (this.schemaVersions == null) {
+      this.schemaVersions = new ArrayList<SchemaVersionDescriptor>();
+    }
+    this.schemaVersions.add(elem);
+  }
+
+  public List<SchemaVersionDescriptor> getSchemaVersions() {
+    return this.schemaVersions;
+  }
+
+  public void setSchemaVersions(List<SchemaVersionDescriptor> schemaVersions) {
+    this.schemaVersions = schemaVersions;
+  }
+
+  public void unsetSchemaVersions() {
+    this.schemaVersions = null;
+  }
+
+  /** Returns true if field schemaVersions is set (has been assigned a value) and false otherwise */
+  public boolean isSetSchemaVersions() {
+    return this.schemaVersions != null;
+  }
+
+  public void setSchemaVersionsIsSet(boolean value) {
+    if (!value) {
+      this.schemaVersions = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case SCHEMA_VERSIONS:
+      if (value == null) {
+        unsetSchemaVersions();
+      } else {
+        setSchemaVersions((List<SchemaVersionDescriptor>)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case SCHEMA_VERSIONS:
+      return getSchemaVersions();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case SCHEMA_VERSIONS:
+      return isSetSchemaVersions();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof FindSchemasByColsResp)
+      return this.equals((FindSchemasByColsResp)that);
+    return false;
+  }
+
+  public boolean equals(FindSchemasByColsResp that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_schemaVersions = true && this.isSetSchemaVersions();
+    boolean that_present_schemaVersions = true && that.isSetSchemaVersions();
+    if (this_present_schemaVersions || that_present_schemaVersions) {
+      if (!(this_present_schemaVersions && that_present_schemaVersions))
+        return false;
+      if (!this.schemaVersions.equals(that.schemaVersions))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_schemaVersions = true && (isSetSchemaVersions());
+    list.add(present_schemaVersions);
+    if (present_schemaVersions)
+      list.add(schemaVersions);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(FindSchemasByColsResp other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetSchemaVersions()).compareTo(other.isSetSchemaVersions());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetSchemaVersions()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.schemaVersions, other.schemaVersions);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("FindSchemasByColsResp(");
+    boolean first = true;
+
+    sb.append("schemaVersions:");
+    if (this.schemaVersions == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.schemaVersions);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class FindSchemasByColsRespStandardSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRespStandardScheme getScheme() {
+      return new FindSchemasByColsRespStandardScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRespStandardScheme extends StandardScheme<FindSchemasByColsResp> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, FindSchemasByColsResp struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // SCHEMA_VERSIONS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list872 = iprot.readListBegin();
+                struct.schemaVersions = new ArrayList<SchemaVersionDescriptor>(_list872.size);
+                SchemaVersionDescriptor _elem873;
+                for (int _i874 = 0; _i874 < _list872.size; ++_i874)
+                {
+                  _elem873 = new SchemaVersionDescriptor();
+                  _elem873.read(iprot);
+                  struct.schemaVersions.add(_elem873);
+                }
+                iprot.readListEnd();
+              }
+              struct.setSchemaVersionsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, FindSchemasByColsResp struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.schemaVersions != null) {
+        oprot.writeFieldBegin(SCHEMA_VERSIONS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.schemaVersions.size()));
+          for (SchemaVersionDescriptor _iter875 : struct.schemaVersions)
+          {
+            _iter875.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class FindSchemasByColsRespTupleSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRespTupleScheme getScheme() {
+      return new FindSchemasByColsRespTupleScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRespTupleScheme extends TupleScheme<FindSchemasByColsResp> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsResp struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetSchemaVersions()) {
+        optionals.set(0);
+      }
+      oprot.writeBitSet(optionals, 1);
+      if (struct.isSetSchemaVersions()) {
+        {
+          oprot.writeI32(struct.schemaVersions.size());
+          for (SchemaVersionDescriptor _iter876 : struct.schemaVersions)
+          {
+            _iter876.write(oprot);
+          }
+        }
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsResp struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(1);
+      if (incoming.get(0)) {
+        {
+          org.apache.thrift.protocol.TList _list877 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.schemaVersions = new ArrayList<SchemaVersionDescriptor>(_list877.size);
+          SchemaVersionDescriptor _elem878;
+          for (int _i879 = 0; _i879 < _list877.size; ++_i879)
+          {
+            _elem878 = new SchemaVersionDescriptor();
+            _elem878.read(iprot);
+            struct.schemaVersions.add(_elem878);
+          }
+        }
+        struct.setSchemaVersionsIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRqst.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRqst.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRqst.java
new file mode 100644
index 0000000..d5230c9
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRqst.java
@@ -0,0 +1,605 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class FindSchemasByColsRqst implements org.apache.thrift.TBase<FindSchemasByColsRqst, FindSchemasByColsRqst._Fields>, java.io.Serializable, Cloneable, Comparable<FindSchemasByColsRqst> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FindSchemasByColsRqst");
+
+  private static final org.apache.thrift.protocol.TField COL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("colName", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField COL_NAMESPACE_FIELD_DESC = new org.apache.thrift.protocol.TField("colNamespace", org.apache.thrift.protocol.TType.STRING, (short)2);
+  private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short)3);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new FindSchemasByColsRqstStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new FindSchemasByColsRqstTupleSchemeFactory());
+  }
+
+  private String colName; // optional
+  private String colNamespace; // optional
+  private String type; // optional
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    COL_NAME((short)1, "colName"),
+    COL_NAMESPACE((short)2, "colNamespace"),
+    TYPE((short)3, "type");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // COL_NAME
+          return COL_NAME;
+        case 2: // COL_NAMESPACE
+          return COL_NAMESPACE;
+        case 3: // TYPE
+          return TYPE;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  private static final _Fields optionals[] = {_Fields.COL_NAME,_Fields.COL_NAMESPACE,_Fields.TYPE};
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.COL_NAME, new org.apache.thrift.meta_data.FieldMetaData("colName", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.COL_NAMESPACE, new org.apache.thrift.meta_data.FieldMetaData("colNamespace", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FindSchemasByColsRqst.class, metaDataMap);
+  }
+
+  public FindSchemasByColsRqst() {
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public FindSchemasByColsRqst(FindSchemasByColsRqst other) {
+    if (other.isSetColName()) {
+      this.colName = other.colName;
+    }
+    if (other.isSetColNamespace()) {
+      this.colNamespace = other.colNamespace;
+    }
+    if (other.isSetType()) {
+      this.type = other.type;
+    }
+  }
+
+  public FindSchemasByColsRqst deepCopy() {
+    return new FindSchemasByColsRqst(this);
+  }
+
+  @Override
+  public void clear() {
+    this.colName = null;
+    this.colNamespace = null;
+    this.type = null;
+  }
+
+  public String getColName() {
+    return this.colName;
+  }
+
+  public void setColName(String colName) {
+    this.colName = colName;
+  }
+
+  public void unsetColName() {
+    this.colName = null;
+  }
+
+  /** Returns true if field colName is set (has been assigned a value) and false otherwise */
+  public boolean isSetColName() {
+    return this.colName != null;
+  }
+
+  public void setColNameIsSet(boolean value) {
+    if (!value) {
+      this.colName = null;
+    }
+  }
+
+  public String getColNamespace() {
+    return this.colNamespace;
+  }
+
+  public void setColNamespace(String colNamespace) {
+    this.colNamespace = colNamespace;
+  }
+
+  public void unsetColNamespace() {
+    this.colNamespace = null;
+  }
+
+  /** Returns true if field colNamespace is set (has been assigned a value) and false otherwise */
+  public boolean isSetColNamespace() {
+    return this.colNamespace != null;
+  }
+
+  public void setColNamespaceIsSet(boolean value) {
+    if (!value) {
+      this.colNamespace = null;
+    }
+  }
+
+  public String getType() {
+    return this.type;
+  }
+
+  public void setType(String type) {
+    this.type = type;
+  }
+
+  public void unsetType() {
+    this.type = null;
+  }
+
+  /** Returns true if field type is set (has been assigned a value) and false otherwise */
+  public boolean isSetType() {
+    return this.type != null;
+  }
+
+  public void setTypeIsSet(boolean value) {
+    if (!value) {
+      this.type = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case COL_NAME:
+      if (value == null) {
+        unsetColName();
+      } else {
+        setColName((String)value);
+      }
+      break;
+
+    case COL_NAMESPACE:
+      if (value == null) {
+        unsetColNamespace();
+      } else {
+        setColNamespace((String)value);
+      }
+      break;
+
+    case TYPE:
+      if (value == null) {
+        unsetType();
+      } else {
+        setType((String)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case COL_NAME:
+      return getColName();
+
+    case COL_NAMESPACE:
+      return getColNamespace();
+
+    case TYPE:
+      return getType();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case COL_NAME:
+      return isSetColName();
+    case COL_NAMESPACE:
+      return isSetColNamespace();
+    case TYPE:
+      return isSetType();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof FindSchemasByColsRqst)
+      return this.equals((FindSchemasByColsRqst)that);
+    return false;
+  }
+
+  public boolean equals(FindSchemasByColsRqst that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_colName = true && this.isSetColName();
+    boolean that_present_colName = true && that.isSetColName();
+    if (this_present_colName || that_present_colName) {
+      if (!(this_present_colName && that_present_colName))
+        return false;
+      if (!this.colName.equals(that.colName))
+        return false;
+    }
+
+    boolean this_present_colNamespace = true && this.isSetColNamespace();
+    boolean that_present_colNamespace = true && that.isSetColNamespace();
+    if (this_present_colNamespace || that_present_colNamespace) {
+      if (!(this_present_colNamespace && that_present_colNamespace))
+        return false;
+      if (!this.colNamespace.equals(that.colNamespace))
+        return false;
+    }
+
+    boolean this_present_type = true && this.isSetType();
+    boolean that_present_type = true && that.isSetType();
+    if (this_present_type || that_present_type) {
+      if (!(this_present_type && that_present_type))
+        return false;
+      if (!this.type.equals(that.type))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_colName = true && (isSetColName());
+    list.add(present_colName);
+    if (present_colName)
+      list.add(colName);
+
+    boolean present_colNamespace = true && (isSetColNamespace());
+    list.add(present_colNamespace);
+    if (present_colNamespace)
+      list.add(colNamespace);
+
+    boolean present_type = true && (isSetType());
+    list.add(present_type);
+    if (present_type)
+      list.add(type);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(FindSchemasByColsRqst other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetColName()).compareTo(other.isSetColName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colName, other.colName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetColNamespace()).compareTo(other.isSetColNamespace());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetColNamespace()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.colNamespace, other.colNamespace);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetType()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("FindSchemasByColsRqst(");
+    boolean first = true;
+
+    if (isSetColName()) {
+      sb.append("colName:");
+      if (this.colName == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.colName);
+      }
+      first = false;
+    }
+    if (isSetColNamespace()) {
+      if (!first) sb.append(", ");
+      sb.append("colNamespace:");
+      if (this.colNamespace == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.colNamespace);
+      }
+      first = false;
+    }
+    if (isSetType()) {
+      if (!first) sb.append(", ");
+      sb.append("type:");
+      if (this.type == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.type);
+      }
+      first = false;
+    }
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class FindSchemasByColsRqstStandardSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRqstStandardScheme getScheme() {
+      return new FindSchemasByColsRqstStandardScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRqstStandardScheme extends StandardScheme<FindSchemasByColsRqst> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, FindSchemasByColsRqst struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // COL_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.colName = iprot.readString();
+              struct.setColNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // COL_NAMESPACE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.colNamespace = iprot.readString();
+              struct.setColNamespaceIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 3: // TYPE
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.type = iprot.readString();
+              struct.setTypeIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, FindSchemasByColsRqst struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.colName != null) {
+        if (struct.isSetColName()) {
+          oprot.writeFieldBegin(COL_NAME_FIELD_DESC);
+          oprot.writeString(struct.colName);
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.colNamespace != null) {
+        if (struct.isSetColNamespace()) {
+          oprot.writeFieldBegin(COL_NAMESPACE_FIELD_DESC);
+          oprot.writeString(struct.colNamespace);
+          oprot.writeFieldEnd();
+        }
+      }
+      if (struct.type != null) {
+        if (struct.isSetType()) {
+          oprot.writeFieldBegin(TYPE_FIELD_DESC);
+          oprot.writeString(struct.type);
+          oprot.writeFieldEnd();
+        }
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class FindSchemasByColsRqstTupleSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRqstTupleScheme getScheme() {
+      return new FindSchemasByColsRqstTupleScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRqstTupleScheme extends TupleScheme<FindSchemasByColsRqst> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsRqst struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetColName()) {
+        optionals.set(0);
+      }
+      if (struct.isSetColNamespace()) {
+        optionals.set(1);
+      }
+      if (struct.isSetType()) {
+        optionals.set(2);
+      }
+      oprot.writeBitSet(optionals, 3);
+      if (struct.isSetColName()) {
+        oprot.writeString(struct.colName);
+      }
+      if (struct.isSetColNamespace()) {
+        oprot.writeString(struct.colNamespace);
+      }
+      if (struct.isSetType()) {
+        oprot.writeString(struct.type);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsRqst struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(3);
+      if (incoming.get(0)) {
+        struct.colName = iprot.readString();
+        struct.setColNameIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.colNamespace = iprot.readString();
+        struct.setColNamespaceIsSet(true);
+      }
+      if (incoming.get(2)) {
+        struct.type = iprot.readString();
+        struct.setTypeIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSerdeRequest.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSerdeRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSerdeRequest.java
new file mode 100644
index 0000000..bf0a595
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/GetSerdeRequest.java
@@ -0,0 +1,395 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+package org.apache.hadoop.hive.metastore.api;
+
+import org.apache.thrift.scheme.IScheme;
+import org.apache.thrift.scheme.SchemeFactory;
+import org.apache.thrift.scheme.StandardScheme;
+
+import org.apache.thrift.scheme.TupleScheme;
+import org.apache.thrift.protocol.TTupleProtocol;
+import org.apache.thrift.protocol.TProtocolException;
+import org.apache.thrift.EncodingUtils;
+import org.apache.thrift.TException;
+import org.apache.thrift.async.AsyncMethodCallback;
+import org.apache.thrift.server.AbstractNonblockingServer.*;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumMap;
+import java.util.Set;
+import java.util.HashSet;
+import java.util.EnumSet;
+import java.util.Collections;
+import java.util.BitSet;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import javax.annotation.Generated;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
+@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)")
+@org.apache.hadoop.classification.InterfaceAudience.Public @org.apache.hadoop.classification.InterfaceStability.Stable public class GetSerdeRequest implements org.apache.thrift.TBase<GetSerdeRequest, GetSerdeRequest._Fields>, java.io.Serializable, Cloneable, Comparable<GetSerdeRequest> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("GetSerdeRequest");
+
+  private static final org.apache.thrift.protocol.TField SERDE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("serdeName", org.apache.thrift.protocol.TType.STRING, (short)1);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new GetSerdeRequestStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new GetSerdeRequestTupleSchemeFactory());
+  }
+
+  private String serdeName; // required
+
+  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+    SERDE_NAME((short)1, "serdeName");
+
+    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+    static {
+      for (_Fields field : EnumSet.allOf(_Fields.class)) {
+        byName.put(field.getFieldName(), field);
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, or null if its not found.
+     */
+    public static _Fields findByThriftId(int fieldId) {
+      switch(fieldId) {
+        case 1: // SERDE_NAME
+          return SERDE_NAME;
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Find the _Fields constant that matches fieldId, throwing an exception
+     * if it is not found.
+     */
+    public static _Fields findByThriftIdOrThrow(int fieldId) {
+      _Fields fields = findByThriftId(fieldId);
+      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+      return fields;
+    }
+
+    /**
+     * Find the _Fields constant that matches name, or null if its not found.
+     */
+    public static _Fields findByName(String name) {
+      return byName.get(name);
+    }
+
+    private final short _thriftId;
+    private final String _fieldName;
+
+    _Fields(short thriftId, String fieldName) {
+      _thriftId = thriftId;
+      _fieldName = fieldName;
+    }
+
+    public short getThriftFieldId() {
+      return _thriftId;
+    }
+
+    public String getFieldName() {
+      return _fieldName;
+    }
+  }
+
+  // isset id assignments
+  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+  static {
+    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+    tmpMap.put(_Fields.SERDE_NAME, new org.apache.thrift.meta_data.FieldMetaData("serdeName", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(GetSerdeRequest.class, metaDataMap);
+  }
+
+  public GetSerdeRequest() {
+  }
+
+  public GetSerdeRequest(
+    String serdeName)
+  {
+    this();
+    this.serdeName = serdeName;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public GetSerdeRequest(GetSerdeRequest other) {
+    if (other.isSetSerdeName()) {
+      this.serdeName = other.serdeName;
+    }
+  }
+
+  public GetSerdeRequest deepCopy() {
+    return new GetSerdeRequest(this);
+  }
+
+  @Override
+  public void clear() {
+    this.serdeName = null;
+  }
+
+  public String getSerdeName() {
+    return this.serdeName;
+  }
+
+  public void setSerdeName(String serdeName) {
+    this.serdeName = serdeName;
+  }
+
+  public void unsetSerdeName() {
+    this.serdeName = null;
+  }
+
+  /** Returns true if field serdeName is set (has been assigned a value) and false otherwise */
+  public boolean isSetSerdeName() {
+    return this.serdeName != null;
+  }
+
+  public void setSerdeNameIsSet(boolean value) {
+    if (!value) {
+      this.serdeName = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case SERDE_NAME:
+      if (value == null) {
+        unsetSerdeName();
+      } else {
+        setSerdeName((String)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case SERDE_NAME:
+      return getSerdeName();
+
+    }
+    throw new IllegalStateException();
+  }
+
+  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+  public boolean isSet(_Fields field) {
+    if (field == null) {
+      throw new IllegalArgumentException();
+    }
+
+    switch (field) {
+    case SERDE_NAME:
+      return isSetSerdeName();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof GetSerdeRequest)
+      return this.equals((GetSerdeRequest)that);
+    return false;
+  }
+
+  public boolean equals(GetSerdeRequest that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_serdeName = true && this.isSetSerdeName();
+    boolean that_present_serdeName = true && that.isSetSerdeName();
+    if (this_present_serdeName || that_present_serdeName) {
+      if (!(this_present_serdeName && that_present_serdeName))
+        return false;
+      if (!this.serdeName.equals(that.serdeName))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_serdeName = true && (isSetSerdeName());
+    list.add(present_serdeName);
+    if (present_serdeName)
+      list.add(serdeName);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(GetSerdeRequest other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetSerdeName()).compareTo(other.isSetSerdeName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetSerdeName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serdeName, other.serdeName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    return 0;
+  }
+
+  public _Fields fieldForId(int fieldId) {
+    return _Fields.findByThriftId(fieldId);
+  }
+
+  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
+  }
+
+  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("GetSerdeRequest(");
+    boolean first = true;
+
+    sb.append("serdeName:");
+    if (this.serdeName == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.serdeName);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    // check for sub-struct validity
+  }
+
+  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+    try {
+      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+    try {
+      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+    } catch (org.apache.thrift.TException te) {
+      throw new java.io.IOException(te);
+    }
+  }
+
+  private static class GetSerdeRequestStandardSchemeFactory implements SchemeFactory {
+    public GetSerdeRequestStandardScheme getScheme() {
+      return new GetSerdeRequestStandardScheme();
+    }
+  }
+
+  private static class GetSerdeRequestStandardScheme extends StandardScheme<GetSerdeRequest> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, GetSerdeRequest struct) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField schemeField;
+      iprot.readStructBegin();
+      while (true)
+      {
+        schemeField = iprot.readFieldBegin();
+        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
+          break;
+        }
+        switch (schemeField.id) {
+          case 1: // SERDE_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.serdeName = iprot.readString();
+              struct.setSerdeNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      struct.validate();
+    }
+
+    public void write(org.apache.thrift.protocol.TProtocol oprot, GetSerdeRequest struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.serdeName != null) {
+        oprot.writeFieldBegin(SERDE_NAME_FIELD_DESC);
+        oprot.writeString(struct.serdeName);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class GetSerdeRequestTupleSchemeFactory implements SchemeFactory {
+    public GetSerdeRequestTupleScheme getScheme() {
+      return new GetSerdeRequestTupleScheme();
+    }
+  }
+
+  private static class GetSerdeRequestTupleScheme extends TupleScheme<GetSerdeRequest> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, GetSerdeRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetSerdeName()) {
+        optionals.set(0);
+      }
+      oprot.writeBitSet(optionals, 1);
+      if (struct.isSetSerdeName()) {
+        oprot.writeString(struct.serdeName);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, GetSerdeRequest struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(1);
+      if (incoming.get(0)) {
+        struct.serdeName = iprot.readString();
+        struct.setSerdeNameIsSet(true);
+      }
+    }
+  }
+
+}
+