http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/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 3218d9a..89484e3 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 @@ -544,6 +597,16 @@ class WMCreateOrDropTriggerToPoolMappingRequest; class WMCreateOrDropTriggerToPoolMappingResponse; +class ISchema; + +class SchemaVersion; + +class FindSchemasByColsRqst; + +class FindSchemasByColsRespEntry; + +class FindSchemasByColsResp; + class MetaException; class UnknownTableException; @@ -2084,10 +2147,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 { @@ -2095,13 +2162,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; @@ -2111,6 +2182,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)) @@ -2119,6 +2198,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 { @@ -10709,6 +10804,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/b6230001/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..cd31e0c --- /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 _list828 = iprot.readListBegin(); + struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list828.size); + FindSchemasByColsRespEntry _elem829; + for (int _i830 = 0; _i830 < _list828.size; ++_i830) + { + _elem829 = new FindSchemasByColsRespEntry(); + _elem829.read(iprot); + struct.schemaVersions.add(_elem829); + } + 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 _iter831 : struct.schemaVersions) + { + _iter831.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 _iter832 : struct.schemaVersions) + { + _iter832.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 _list833 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.schemaVersions = new ArrayList<FindSchemasByColsRespEntry>(_list833.size); + FindSchemasByColsRespEntry _elem834; + for (int _i835 = 0; _i835 < _list833.size; ++_i835) + { + _elem834 = new FindSchemasByColsRespEntry(); + _elem834.read(iprot); + struct.schemaVersions.add(_elem834); + } + } + struct.setSchemaVersionsIsSet(true); + } + } + } + +} + http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/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/b6230001/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); + } + } + } + +} +
