You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ga...@apache.org on 2018/02/12 18:42:53 UTC
[43/50] [abbrv] hive git commit: HIVE-17990 Add Thrift and DB storage
for Schema Registry objects
http://git-wip-us.apache.org/repos/asf/hive/blob/a9e1acaf/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 4c09bc8..6346ede 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
@@ -548,6 +601,16 @@ class WMCreateOrDropTriggerToPoolMappingRequest;
class WMCreateOrDropTriggerToPoolMappingResponse;
+class ISchema;
+
+class SchemaVersion;
+
+class FindSchemasByColsRqst;
+
+class FindSchemasByColsRespEntry;
+
+class FindSchemasByColsResp;
+
class MetaException;
class UnknownTableException;
@@ -2088,10 +2151,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 {
@@ -2099,13 +2166,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;
@@ -2115,6 +2186,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))
@@ -2123,6 +2202,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 {
@@ -10898,6 +10993,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/a9e1acaf/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..ec01a6b
--- /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 _list826 = iprot.readListBegin();
+ struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list826.size);
+ FindSchemasByColsRespEntry _elem827;
+ for (int _i828 = 0; _i828 < _list826.size; ++_i828)
+ {
+ _elem827 = new FindSchemasByColsRespEntry();
+ _elem827.read(iprot);
+ struct.schemaVersions.add(_elem827);
+ }
+ 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 _iter829 : struct.schemaVersions)
+ {
+ _iter829.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 _iter830 : struct.schemaVersions)
+ {
+ _iter830.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 _list831 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
+ struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list831.size);
+ FindSchemasByColsRespEntry _elem832;
+ for (int _i833 = 0; _i833 < _list831.size; ++_i833)
+ {
+ _elem832 = new FindSchemasByColsRespEntry();
+ _elem832.read(iprot);
+ struct.schemaVersions.add(_elem832);
+ }
+ }
+ struct.setSchemaVersionsIsSet(true);
+ }
+ }
+ }
+
+}
+
http://git-wip-us.apache.org/repos/asf/hive/blob/a9e1acaf/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/a9e1acaf/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);
+ }
+ }
+ }
+
+}
+