hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ga...@apache.org
Subject [45/50] [abbrv] hive git commit: HIVE-17990 Add Thrift and DB storage for Schema Registry objects
Date Thu, 07 Dec 2017 17:54:27 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/bd212257/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 2219811..cc94082 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
@@ -529,6 +582,16 @@ class WMCreateOrDropTriggerToPoolMappingRequest;
 
 class WMCreateOrDropTriggerToPoolMappingResponse;
 
+class ISchema;
+
+class SchemaVersion;
+
+class FindSchemasByColsRqst;
+
+class FindSchemasByColsRespEntry;
+
+class FindSchemasByColsResp;
+
 class MetaException;
 
 class UnknownTableException;
@@ -2069,10 +2132,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 {
@@ -2080,13 +2147,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;
 
@@ -2096,6 +2167,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))
@@ -2104,6 +2183,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 {
@@ -10466,6 +10561,372 @@ 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 _SchemaVersion__isset {
+  _SchemaVersion__isset() : schemaName(false), version(false), createdAt(false), cols(false), state(false), description(false), schemaText(false), fingerprint(false), name(false), serDe(false) {}
+  bool schemaName :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() : schemaName(), version(0), createdAt(0), state((SchemaVersionState::type)0), description(), schemaText(), fingerprint(), name() {
+  }
+
+  virtual ~SchemaVersion() throw();
+  std::string schemaName;
+  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_schemaName(const std::string& 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 (!(schemaName == rhs.schemaName))
+      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 _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 _FindSchemasByColsRespEntry__isset {
+  _FindSchemasByColsRespEntry__isset() : schemaName(false), version(false) {}
+  bool schemaName :1;
+  bool version :1;
+} _FindSchemasByColsRespEntry__isset;
+
+class FindSchemasByColsRespEntry {
+ public:
+
+  FindSchemasByColsRespEntry(const FindSchemasByColsRespEntry&);
+  FindSchemasByColsRespEntry& operator=(const FindSchemasByColsRespEntry&);
+  FindSchemasByColsRespEntry() : schemaName(), version(0) {
+  }
+
+  virtual ~FindSchemasByColsRespEntry() throw();
+  std::string schemaName;
+  int32_t version;
+
+  _FindSchemasByColsRespEntry__isset __isset;
+
+  void __set_schemaName(const std::string& val);
+
+  void __set_version(const int32_t val);
+
+  bool operator == (const FindSchemasByColsRespEntry & rhs) const
+  {
+    if (!(schemaName == rhs.schemaName))
+      return false;
+    if (!(version == rhs.version))
+      return false;
+    return true;
+  }
+  bool operator != (const FindSchemasByColsRespEntry &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const FindSchemasByColsRespEntry & ) 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(FindSchemasByColsRespEntry &a, FindSchemasByColsRespEntry &b);
+
+inline std::ostream& operator<<(std::ostream& out, const FindSchemasByColsRespEntry& 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<FindSchemasByColsRespEntry>  schemaVersions;
+
+  _FindSchemasByColsResp__isset __isset;
+
+  void __set_schemaVersions(const std::vector<FindSchemasByColsRespEntry> & 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 _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message :1;

http://git-wip-us.apache.org/repos/asf/hive/blob/bd212257/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..5ba07d7
--- /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<FindSchemasByColsRespEntry> 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, FindSchemasByColsRespEntry.class))));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FindSchemasByColsResp.class, metaDataMap);
+  }
+
+  public FindSchemasByColsResp() {
+  }
+
+  public FindSchemasByColsResp(
+    List<FindSchemasByColsRespEntry> schemaVersions)
+  {
+    this();
+    this.schemaVersions = schemaVersions;
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public FindSchemasByColsResp(FindSchemasByColsResp other) {
+    if (other.isSetSchemaVersions()) {
+      List<FindSchemasByColsRespEntry> __this__schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(other.schemaVersions.size());
+      for (FindSchemasByColsRespEntry other_element : other.schemaVersions) {
+        __this__schemaVersions.add(new FindSchemasByColsRespEntry(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<FindSchemasByColsRespEntry> getSchemaVersionsIterator() {
+    return (this.schemaVersions == null) ? null : this.schemaVersions.iterator();
+  }
+
+  public void addToSchemaVersions(FindSchemasByColsRespEntry elem) {
+    if (this.schemaVersions == null) {
+      this.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>();
+    }
+    this.schemaVersions.add(elem);
+  }
+
+  public List<FindSchemasByColsRespEntry> getSchemaVersions() {
+    return this.schemaVersions;
+  }
+
+  public void setSchemaVersions(List<FindSchemasByColsRespEntry> 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<FindSchemasByColsRespEntry>)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 _list802 = iprot.readListBegin();
+                struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list802.size);
+                FindSchemasByColsRespEntry _elem803;
+                for (int _i804 = 0; _i804 < _list802.size; ++_i804)
+                {
+                  _elem803 = new FindSchemasByColsRespEntry();
+                  _elem803.read(iprot);
+                  struct.schemaVersions.add(_elem803);
+                }
+                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 (FindSchemasByColsRespEntry _iter805 : struct.schemaVersions)
+          {
+            _iter805.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 (FindSchemasByColsRespEntry _iter806 : struct.schemaVersions)
+          {
+            _iter806.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 _list807 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+          struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list807.size);
+          FindSchemasByColsRespEntry _elem808;
+          for (int _i809 = 0; _i809 < _list807.size; ++_i809)
+          {
+            _elem808 = new FindSchemasByColsRespEntry();
+            _elem808.read(iprot);
+            struct.schemaVersions.add(_elem808);
+          }
+        }
+        struct.setSchemaVersionsIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/bd212257/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRespEntry.java
----------------------------------------------------------------------
diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRespEntry.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRespEntry.java
new file mode 100644
index 0000000..5a71d21
--- /dev/null
+++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/FindSchemasByColsRespEntry.java
@@ -0,0 +1,497 @@
+/**
+ * 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 FindSchemasByColsRespEntry implements org.apache.thrift.TBase<FindSchemasByColsRespEntry, FindSchemasByColsRespEntry._Fields>, java.io.Serializable, Cloneable, Comparable<FindSchemasByColsRespEntry> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FindSchemasByColsRespEntry");
+
+  private static final org.apache.thrift.protocol.TField SCHEMA_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("schemaName", org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField VERSION_FIELD_DESC = new org.apache.thrift.protocol.TField("version", org.apache.thrift.protocol.TType.I32, (short)2);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new FindSchemasByColsRespEntryStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new FindSchemasByColsRespEntryTupleSchemeFactory());
+  }
+
+  private String schemaName; // required
+  private int version; // 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_NAME((short)1, "schemaName"),
+    VERSION((short)2, "version");
+
+    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_NAME
+          return SCHEMA_NAME;
+        case 2: // VERSION
+          return VERSION;
+        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 int __VERSION_ISSET_ID = 0;
+  private byte __isset_bitfield = 0;
+  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_NAME, new org.apache.thrift.meta_data.FieldMetaData("schemaName", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.VERSION, new org.apache.thrift.meta_data.FieldMetaData("version", org.apache.thrift.TFieldRequirementType.DEFAULT, 
+        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FindSchemasByColsRespEntry.class, metaDataMap);
+  }
+
+  public FindSchemasByColsRespEntry() {
+  }
+
+  public FindSchemasByColsRespEntry(
+    String schemaName,
+    int version)
+  {
+    this();
+    this.schemaName = schemaName;
+    this.version = version;
+    setVersionIsSet(true);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public FindSchemasByColsRespEntry(FindSchemasByColsRespEntry other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetSchemaName()) {
+      this.schemaName = other.schemaName;
+    }
+    this.version = other.version;
+  }
+
+  public FindSchemasByColsRespEntry deepCopy() {
+    return new FindSchemasByColsRespEntry(this);
+  }
+
+  @Override
+  public void clear() {
+    this.schemaName = null;
+    setVersionIsSet(false);
+    this.version = 0;
+  }
+
+  public String getSchemaName() {
+    return this.schemaName;
+  }
+
+  public void setSchemaName(String schemaName) {
+    this.schemaName = schemaName;
+  }
+
+  public void unsetSchemaName() {
+    this.schemaName = null;
+  }
+
+  /** Returns true if field schemaName is set (has been assigned a value) and false otherwise */
+  public boolean isSetSchemaName() {
+    return this.schemaName != null;
+  }
+
+  public void setSchemaNameIsSet(boolean value) {
+    if (!value) {
+      this.schemaName = null;
+    }
+  }
+
+  public int getVersion() {
+    return this.version;
+  }
+
+  public void setVersion(int version) {
+    this.version = version;
+    setVersionIsSet(true);
+  }
+
+  public void unsetVersion() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __VERSION_ISSET_ID);
+  }
+
+  /** Returns true if field version is set (has been assigned a value) and false otherwise */
+  public boolean isSetVersion() {
+    return EncodingUtils.testBit(__isset_bitfield, __VERSION_ISSET_ID);
+  }
+
+  public void setVersionIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __VERSION_ISSET_ID, value);
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case SCHEMA_NAME:
+      if (value == null) {
+        unsetSchemaName();
+      } else {
+        setSchemaName((String)value);
+      }
+      break;
+
+    case VERSION:
+      if (value == null) {
+        unsetVersion();
+      } else {
+        setVersion((Integer)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case SCHEMA_NAME:
+      return getSchemaName();
+
+    case VERSION:
+      return getVersion();
+
+    }
+    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_NAME:
+      return isSetSchemaName();
+    case VERSION:
+      return isSetVersion();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof FindSchemasByColsRespEntry)
+      return this.equals((FindSchemasByColsRespEntry)that);
+    return false;
+  }
+
+  public boolean equals(FindSchemasByColsRespEntry that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_schemaName = true && this.isSetSchemaName();
+    boolean that_present_schemaName = true && that.isSetSchemaName();
+    if (this_present_schemaName || that_present_schemaName) {
+      if (!(this_present_schemaName && that_present_schemaName))
+        return false;
+      if (!this.schemaName.equals(that.schemaName))
+        return false;
+    }
+
+    boolean this_present_version = true;
+    boolean that_present_version = true;
+    if (this_present_version || that_present_version) {
+      if (!(this_present_version && that_present_version))
+        return false;
+      if (this.version != that.version)
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_schemaName = true && (isSetSchemaName());
+    list.add(present_schemaName);
+    if (present_schemaName)
+      list.add(schemaName);
+
+    boolean present_version = true;
+    list.add(present_version);
+    if (present_version)
+      list.add(version);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(FindSchemasByColsRespEntry other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = Boolean.valueOf(isSetSchemaName()).compareTo(other.isSetSchemaName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetSchemaName()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.schemaName, other.schemaName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = Boolean.valueOf(isSetVersion()).compareTo(other.isSetVersion());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetVersion()) {
+      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.version, other.version);
+      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("FindSchemasByColsRespEntry(");
+    boolean first = true;
+
+    sb.append("schemaName:");
+    if (this.schemaName == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.schemaName);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("version:");
+    sb.append(this.version);
+    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 {
+      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+      __isset_bitfield = 0;
+      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 FindSchemasByColsRespEntryStandardSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRespEntryStandardScheme getScheme() {
+      return new FindSchemasByColsRespEntryStandardScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRespEntryStandardScheme extends StandardScheme<FindSchemasByColsRespEntry> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, FindSchemasByColsRespEntry 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_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.schemaName = iprot.readString();
+              struct.setSchemaNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
+            }
+            break;
+          case 2: // VERSION
+            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
+              struct.version = iprot.readI32();
+              struct.setVersionIsSet(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, FindSchemasByColsRespEntry struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.schemaName != null) {
+        oprot.writeFieldBegin(SCHEMA_NAME_FIELD_DESC);
+        oprot.writeString(struct.schemaName);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(VERSION_FIELD_DESC);
+      oprot.writeI32(struct.version);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class FindSchemasByColsRespEntryTupleSchemeFactory implements SchemeFactory {
+    public FindSchemasByColsRespEntryTupleScheme getScheme() {
+      return new FindSchemasByColsRespEntryTupleScheme();
+    }
+  }
+
+  private static class FindSchemasByColsRespEntryTupleScheme extends TupleScheme<FindSchemasByColsRespEntry> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsRespEntry struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      BitSet optionals = new BitSet();
+      if (struct.isSetSchemaName()) {
+        optionals.set(0);
+      }
+      if (struct.isSetVersion()) {
+        optionals.set(1);
+      }
+      oprot.writeBitSet(optionals, 2);
+      if (struct.isSetSchemaName()) {
+        oprot.writeString(struct.schemaName);
+      }
+      if (struct.isSetVersion()) {
+        oprot.writeI32(struct.version);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, FindSchemasByColsRespEntry struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      BitSet incoming = iprot.readBitSet(2);
+      if (incoming.get(0)) {
+        struct.schemaName = iprot.readString();
+        struct.setSchemaNameIsSet(true);
+      }
+      if (incoming.get(1)) {
+        struct.version = iprot.readI32();
+        struct.setVersionIsSet(true);
+      }
+    }
+  }
+
+}
+

http://git-wip-us.apache.org/repos/asf/hive/blob/bd212257/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);
+      }
+    }
+  }
+
+}
+


Mime
View raw message