http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java index bcfc75b..a2a5fe6 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/NotificationEventResponse.java @@ -354,14 +354,14 @@ public class NotificationEventResponse implements org.apache.thrift.TBase<Notifi case 1: // EVENTS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list582 = iprot.readListBegin(); - struct.events = new ArrayList<NotificationEvent>(_list582.size); - NotificationEvent _elem583; - for (int _i584 = 0; _i584 < _list582.size; ++_i584) + org.apache.thrift.protocol.TList _list614 = iprot.readListBegin(); + struct.events = new ArrayList<NotificationEvent>(_list614.size); + NotificationEvent _elem615; + for (int _i616 = 0; _i616 < _list614.size; ++_i616) { - _elem583 = new NotificationEvent(); - _elem583.read(iprot); - struct.events.add(_elem583); + _elem615 = new NotificationEvent(); + _elem615.read(iprot); + struct.events.add(_elem615); } iprot.readListEnd(); } @@ -387,9 +387,9 @@ public class NotificationEventResponse implements org.apache.thrift.TBase<Notifi oprot.writeFieldBegin(EVENTS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.events.size())); - for (NotificationEvent _iter585 : struct.events) + for (NotificationEvent _iter617 : struct.events) { - _iter585.write(oprot); + _iter617.write(oprot); } oprot.writeListEnd(); } @@ -414,9 +414,9 @@ public class NotificationEventResponse implements org.apache.thrift.TBase<Notifi TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.events.size()); - for (NotificationEvent _iter586 : struct.events) + for (NotificationEvent _iter618 : struct.events) { - _iter586.write(oprot); + _iter618.write(oprot); } } } @@ -425,14 +425,14 @@ public class NotificationEventResponse implements org.apache.thrift.TBase<Notifi public void read(org.apache.thrift.protocol.TProtocol prot, NotificationEventResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list587 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.events = new ArrayList<NotificationEvent>(_list587.size); - NotificationEvent _elem588; - for (int _i589 = 0; _i589 < _list587.size; ++_i589) + org.apache.thrift.protocol.TList _list619 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.events = new ArrayList<NotificationEvent>(_list619.size); + NotificationEvent _elem620; + for (int _i621 = 0; _i621 < _list619.size; ++_i621) { - _elem588 = new NotificationEvent(); - _elem588.read(iprot); - struct.events.add(_elem588); + _elem620 = new NotificationEvent(); + _elem620.read(iprot); + struct.events.add(_elem620); } } struct.setEventsIsSet(true);
http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java index c23482a..c706f84 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/OpenTxnsResponse.java @@ -351,13 +351,13 @@ public class OpenTxnsResponse implements org.apache.thrift.TBase<OpenTxnsRespons case 1: // TXN_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list508 = iprot.readListBegin(); - struct.txn_ids = new ArrayList<Long>(_list508.size); - long _elem509; - for (int _i510 = 0; _i510 < _list508.size; ++_i510) + org.apache.thrift.protocol.TList _list540 = iprot.readListBegin(); + struct.txn_ids = new ArrayList<Long>(_list540.size); + long _elem541; + for (int _i542 = 0; _i542 < _list540.size; ++_i542) { - _elem509 = iprot.readI64(); - struct.txn_ids.add(_elem509); + _elem541 = iprot.readI64(); + struct.txn_ids.add(_elem541); } iprot.readListEnd(); } @@ -383,9 +383,9 @@ public class OpenTxnsResponse implements org.apache.thrift.TBase<OpenTxnsRespons oprot.writeFieldBegin(TXN_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.txn_ids.size())); - for (long _iter511 : struct.txn_ids) + for (long _iter543 : struct.txn_ids) { - oprot.writeI64(_iter511); + oprot.writeI64(_iter543); } oprot.writeListEnd(); } @@ -410,9 +410,9 @@ public class OpenTxnsResponse implements org.apache.thrift.TBase<OpenTxnsRespons TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.txn_ids.size()); - for (long _iter512 : struct.txn_ids) + for (long _iter544 : struct.txn_ids) { - oprot.writeI64(_iter512); + oprot.writeI64(_iter544); } } } @@ -421,13 +421,13 @@ public class OpenTxnsResponse implements org.apache.thrift.TBase<OpenTxnsRespons public void read(org.apache.thrift.protocol.TProtocol prot, OpenTxnsResponse struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list513 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.txn_ids = new ArrayList<Long>(_list513.size); - long _elem514; - for (int _i515 = 0; _i515 < _list513.size; ++_i515) + org.apache.thrift.protocol.TList _list545 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.txn_ids = new ArrayList<Long>(_list545.size); + long _elem546; + for (int _i547 = 0; _i547 < _list545.size; ++_i547) { - _elem514 = iprot.readI64(); - struct.txn_ids.add(_elem514); + _elem546 = iprot.readI64(); + struct.txn_ids.add(_elem546); } } struct.setTxn_idsIsSet(true); http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRequest.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRequest.java new file mode 100644 index 0000000..9e0af3e --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRequest.java @@ -0,0 +1,1222 @@ +/** + * 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)") +public class PartitionValuesRequest implements org.apache.thrift.TBase<PartitionValuesRequest, PartitionValuesRequest._Fields>, java.io.Serializable, Cloneable, Comparable<PartitionValuesRequest> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionValuesRequest"); + + private static final org.apache.thrift.protocol.TField DB_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("dbName", org.apache.thrift.protocol.TType.STRING, (short)1); + private static final org.apache.thrift.protocol.TField TBL_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("tblName", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final org.apache.thrift.protocol.TField PARTITION_KEYS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionKeys", org.apache.thrift.protocol.TType.LIST, (short)3); + private static final org.apache.thrift.protocol.TField APPLY_DISTINCT_FIELD_DESC = new org.apache.thrift.protocol.TField("applyDistinct", org.apache.thrift.protocol.TType.BOOL, (short)4); + private static final org.apache.thrift.protocol.TField FILTER_FIELD_DESC = new org.apache.thrift.protocol.TField("filter", org.apache.thrift.protocol.TType.STRING, (short)5); + private static final org.apache.thrift.protocol.TField PARTITION_ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionOrder", org.apache.thrift.protocol.TType.LIST, (short)6); + private static final org.apache.thrift.protocol.TField ASCENDING_FIELD_DESC = new org.apache.thrift.protocol.TField("ascending", org.apache.thrift.protocol.TType.BOOL, (short)7); + private static final org.apache.thrift.protocol.TField MAX_PARTS_FIELD_DESC = new org.apache.thrift.protocol.TField("maxParts", org.apache.thrift.protocol.TType.I64, (short)8); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new PartitionValuesRequestStandardSchemeFactory()); + schemes.put(TupleScheme.class, new PartitionValuesRequestTupleSchemeFactory()); + } + + private String dbName; // required + private String tblName; // required + private List<FieldSchema> partitionKeys; // required + private boolean applyDistinct; // optional + private String filter; // optional + private List<FieldSchema> partitionOrder; // optional + private boolean ascending; // optional + private long maxParts; // 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 { + DB_NAME((short)1, "dbName"), + TBL_NAME((short)2, "tblName"), + PARTITION_KEYS((short)3, "partitionKeys"), + APPLY_DISTINCT((short)4, "applyDistinct"), + FILTER((short)5, "filter"), + PARTITION_ORDER((short)6, "partitionOrder"), + ASCENDING((short)7, "ascending"), + MAX_PARTS((short)8, "maxParts"); + + 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: // DB_NAME + return DB_NAME; + case 2: // TBL_NAME + return TBL_NAME; + case 3: // PARTITION_KEYS + return PARTITION_KEYS; + case 4: // APPLY_DISTINCT + return APPLY_DISTINCT; + case 5: // FILTER + return FILTER; + case 6: // PARTITION_ORDER + return PARTITION_ORDER; + case 7: // ASCENDING + return ASCENDING; + case 8: // MAX_PARTS + return MAX_PARTS; + 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 __APPLYDISTINCT_ISSET_ID = 0; + private static final int __ASCENDING_ISSET_ID = 1; + private static final int __MAXPARTS_ISSET_ID = 2; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.APPLY_DISTINCT,_Fields.FILTER,_Fields.PARTITION_ORDER,_Fields.ASCENDING,_Fields.MAX_PARTS}; + 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.DB_NAME, new org.apache.thrift.meta_data.FieldMetaData("dbName", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.TBL_NAME, new org.apache.thrift.meta_data.FieldMetaData("tblName", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PARTITION_KEYS, new org.apache.thrift.meta_data.FieldMetaData("partitionKeys", org.apache.thrift.TFieldRequirementType.REQUIRED, + 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, FieldSchema.class)))); + tmpMap.put(_Fields.APPLY_DISTINCT, new org.apache.thrift.meta_data.FieldMetaData("applyDistinct", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.FILTER, new org.apache.thrift.meta_data.FieldMetaData("filter", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PARTITION_ORDER, new org.apache.thrift.meta_data.FieldMetaData("partitionOrder", org.apache.thrift.TFieldRequirementType.OPTIONAL, + 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, FieldSchema.class)))); + tmpMap.put(_Fields.ASCENDING, new org.apache.thrift.meta_data.FieldMetaData("ascending", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.MAX_PARTS, new org.apache.thrift.meta_data.FieldMetaData("maxParts", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PartitionValuesRequest.class, metaDataMap); + } + + public PartitionValuesRequest() { + this.applyDistinct = true; + + this.ascending = true; + + this.maxParts = -1L; + + } + + public PartitionValuesRequest( + String dbName, + String tblName, + List<FieldSchema> partitionKeys) + { + this(); + this.dbName = dbName; + this.tblName = tblName; + this.partitionKeys = partitionKeys; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public PartitionValuesRequest(PartitionValuesRequest other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDbName()) { + this.dbName = other.dbName; + } + if (other.isSetTblName()) { + this.tblName = other.tblName; + } + if (other.isSetPartitionKeys()) { + List<FieldSchema> __this__partitionKeys = new ArrayList<FieldSchema>(other.partitionKeys.size()); + for (FieldSchema other_element : other.partitionKeys) { + __this__partitionKeys.add(new FieldSchema(other_element)); + } + this.partitionKeys = __this__partitionKeys; + } + this.applyDistinct = other.applyDistinct; + if (other.isSetFilter()) { + this.filter = other.filter; + } + if (other.isSetPartitionOrder()) { + List<FieldSchema> __this__partitionOrder = new ArrayList<FieldSchema>(other.partitionOrder.size()); + for (FieldSchema other_element : other.partitionOrder) { + __this__partitionOrder.add(new FieldSchema(other_element)); + } + this.partitionOrder = __this__partitionOrder; + } + this.ascending = other.ascending; + this.maxParts = other.maxParts; + } + + public PartitionValuesRequest deepCopy() { + return new PartitionValuesRequest(this); + } + + @Override + public void clear() { + this.dbName = null; + this.tblName = null; + this.partitionKeys = null; + this.applyDistinct = true; + + this.filter = null; + this.partitionOrder = null; + this.ascending = true; + + this.maxParts = -1L; + + } + + public String getDbName() { + return this.dbName; + } + + public void setDbName(String dbName) { + this.dbName = dbName; + } + + public void unsetDbName() { + this.dbName = null; + } + + /** Returns true if field dbName is set (has been assigned a value) and false otherwise */ + public boolean isSetDbName() { + return this.dbName != null; + } + + public void setDbNameIsSet(boolean value) { + if (!value) { + this.dbName = null; + } + } + + public String getTblName() { + return this.tblName; + } + + public void setTblName(String tblName) { + this.tblName = tblName; + } + + public void unsetTblName() { + this.tblName = null; + } + + /** Returns true if field tblName is set (has been assigned a value) and false otherwise */ + public boolean isSetTblName() { + return this.tblName != null; + } + + public void setTblNameIsSet(boolean value) { + if (!value) { + this.tblName = null; + } + } + + public int getPartitionKeysSize() { + return (this.partitionKeys == null) ? 0 : this.partitionKeys.size(); + } + + public java.util.Iterator<FieldSchema> getPartitionKeysIterator() { + return (this.partitionKeys == null) ? null : this.partitionKeys.iterator(); + } + + public void addToPartitionKeys(FieldSchema elem) { + if (this.partitionKeys == null) { + this.partitionKeys = new ArrayList<FieldSchema>(); + } + this.partitionKeys.add(elem); + } + + public List<FieldSchema> getPartitionKeys() { + return this.partitionKeys; + } + + public void setPartitionKeys(List<FieldSchema> partitionKeys) { + this.partitionKeys = partitionKeys; + } + + public void unsetPartitionKeys() { + this.partitionKeys = null; + } + + /** Returns true if field partitionKeys is set (has been assigned a value) and false otherwise */ + public boolean isSetPartitionKeys() { + return this.partitionKeys != null; + } + + public void setPartitionKeysIsSet(boolean value) { + if (!value) { + this.partitionKeys = null; + } + } + + public boolean isApplyDistinct() { + return this.applyDistinct; + } + + public void setApplyDistinct(boolean applyDistinct) { + this.applyDistinct = applyDistinct; + setApplyDistinctIsSet(true); + } + + public void unsetApplyDistinct() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __APPLYDISTINCT_ISSET_ID); + } + + /** Returns true if field applyDistinct is set (has been assigned a value) and false otherwise */ + public boolean isSetApplyDistinct() { + return EncodingUtils.testBit(__isset_bitfield, __APPLYDISTINCT_ISSET_ID); + } + + public void setApplyDistinctIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __APPLYDISTINCT_ISSET_ID, value); + } + + public String getFilter() { + return this.filter; + } + + public void setFilter(String filter) { + this.filter = filter; + } + + public void unsetFilter() { + this.filter = null; + } + + /** Returns true if field filter is set (has been assigned a value) and false otherwise */ + public boolean isSetFilter() { + return this.filter != null; + } + + public void setFilterIsSet(boolean value) { + if (!value) { + this.filter = null; + } + } + + public int getPartitionOrderSize() { + return (this.partitionOrder == null) ? 0 : this.partitionOrder.size(); + } + + public java.util.Iterator<FieldSchema> getPartitionOrderIterator() { + return (this.partitionOrder == null) ? null : this.partitionOrder.iterator(); + } + + public void addToPartitionOrder(FieldSchema elem) { + if (this.partitionOrder == null) { + this.partitionOrder = new ArrayList<FieldSchema>(); + } + this.partitionOrder.add(elem); + } + + public List<FieldSchema> getPartitionOrder() { + return this.partitionOrder; + } + + public void setPartitionOrder(List<FieldSchema> partitionOrder) { + this.partitionOrder = partitionOrder; + } + + public void unsetPartitionOrder() { + this.partitionOrder = null; + } + + /** Returns true if field partitionOrder is set (has been assigned a value) and false otherwise */ + public boolean isSetPartitionOrder() { + return this.partitionOrder != null; + } + + public void setPartitionOrderIsSet(boolean value) { + if (!value) { + this.partitionOrder = null; + } + } + + public boolean isAscending() { + return this.ascending; + } + + public void setAscending(boolean ascending) { + this.ascending = ascending; + setAscendingIsSet(true); + } + + public void unsetAscending() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ASCENDING_ISSET_ID); + } + + /** Returns true if field ascending is set (has been assigned a value) and false otherwise */ + public boolean isSetAscending() { + return EncodingUtils.testBit(__isset_bitfield, __ASCENDING_ISSET_ID); + } + + public void setAscendingIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ASCENDING_ISSET_ID, value); + } + + public long getMaxParts() { + return this.maxParts; + } + + public void setMaxParts(long maxParts) { + this.maxParts = maxParts; + setMaxPartsIsSet(true); + } + + public void unsetMaxParts() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MAXPARTS_ISSET_ID); + } + + /** Returns true if field maxParts is set (has been assigned a value) and false otherwise */ + public boolean isSetMaxParts() { + return EncodingUtils.testBit(__isset_bitfield, __MAXPARTS_ISSET_ID); + } + + public void setMaxPartsIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MAXPARTS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DB_NAME: + if (value == null) { + unsetDbName(); + } else { + setDbName((String)value); + } + break; + + case TBL_NAME: + if (value == null) { + unsetTblName(); + } else { + setTblName((String)value); + } + break; + + case PARTITION_KEYS: + if (value == null) { + unsetPartitionKeys(); + } else { + setPartitionKeys((List<FieldSchema>)value); + } + break; + + case APPLY_DISTINCT: + if (value == null) { + unsetApplyDistinct(); + } else { + setApplyDistinct((Boolean)value); + } + break; + + case FILTER: + if (value == null) { + unsetFilter(); + } else { + setFilter((String)value); + } + break; + + case PARTITION_ORDER: + if (value == null) { + unsetPartitionOrder(); + } else { + setPartitionOrder((List<FieldSchema>)value); + } + break; + + case ASCENDING: + if (value == null) { + unsetAscending(); + } else { + setAscending((Boolean)value); + } + break; + + case MAX_PARTS: + if (value == null) { + unsetMaxParts(); + } else { + setMaxParts((Long)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case DB_NAME: + return getDbName(); + + case TBL_NAME: + return getTblName(); + + case PARTITION_KEYS: + return getPartitionKeys(); + + case APPLY_DISTINCT: + return isApplyDistinct(); + + case FILTER: + return getFilter(); + + case PARTITION_ORDER: + return getPartitionOrder(); + + case ASCENDING: + return isAscending(); + + case MAX_PARTS: + return getMaxParts(); + + } + 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 DB_NAME: + return isSetDbName(); + case TBL_NAME: + return isSetTblName(); + case PARTITION_KEYS: + return isSetPartitionKeys(); + case APPLY_DISTINCT: + return isSetApplyDistinct(); + case FILTER: + return isSetFilter(); + case PARTITION_ORDER: + return isSetPartitionOrder(); + case ASCENDING: + return isSetAscending(); + case MAX_PARTS: + return isSetMaxParts(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof PartitionValuesRequest) + return this.equals((PartitionValuesRequest)that); + return false; + } + + public boolean equals(PartitionValuesRequest that) { + if (that == null) + return false; + + boolean this_present_dbName = true && this.isSetDbName(); + boolean that_present_dbName = true && that.isSetDbName(); + if (this_present_dbName || that_present_dbName) { + if (!(this_present_dbName && that_present_dbName)) + return false; + if (!this.dbName.equals(that.dbName)) + return false; + } + + boolean this_present_tblName = true && this.isSetTblName(); + boolean that_present_tblName = true && that.isSetTblName(); + if (this_present_tblName || that_present_tblName) { + if (!(this_present_tblName && that_present_tblName)) + return false; + if (!this.tblName.equals(that.tblName)) + return false; + } + + boolean this_present_partitionKeys = true && this.isSetPartitionKeys(); + boolean that_present_partitionKeys = true && that.isSetPartitionKeys(); + if (this_present_partitionKeys || that_present_partitionKeys) { + if (!(this_present_partitionKeys && that_present_partitionKeys)) + return false; + if (!this.partitionKeys.equals(that.partitionKeys)) + return false; + } + + boolean this_present_applyDistinct = true && this.isSetApplyDistinct(); + boolean that_present_applyDistinct = true && that.isSetApplyDistinct(); + if (this_present_applyDistinct || that_present_applyDistinct) { + if (!(this_present_applyDistinct && that_present_applyDistinct)) + return false; + if (this.applyDistinct != that.applyDistinct) + return false; + } + + boolean this_present_filter = true && this.isSetFilter(); + boolean that_present_filter = true && that.isSetFilter(); + if (this_present_filter || that_present_filter) { + if (!(this_present_filter && that_present_filter)) + return false; + if (!this.filter.equals(that.filter)) + return false; + } + + boolean this_present_partitionOrder = true && this.isSetPartitionOrder(); + boolean that_present_partitionOrder = true && that.isSetPartitionOrder(); + if (this_present_partitionOrder || that_present_partitionOrder) { + if (!(this_present_partitionOrder && that_present_partitionOrder)) + return false; + if (!this.partitionOrder.equals(that.partitionOrder)) + return false; + } + + boolean this_present_ascending = true && this.isSetAscending(); + boolean that_present_ascending = true && that.isSetAscending(); + if (this_present_ascending || that_present_ascending) { + if (!(this_present_ascending && that_present_ascending)) + return false; + if (this.ascending != that.ascending) + return false; + } + + boolean this_present_maxParts = true && this.isSetMaxParts(); + boolean that_present_maxParts = true && that.isSetMaxParts(); + if (this_present_maxParts || that_present_maxParts) { + if (!(this_present_maxParts && that_present_maxParts)) + return false; + if (this.maxParts != that.maxParts) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_dbName = true && (isSetDbName()); + list.add(present_dbName); + if (present_dbName) + list.add(dbName); + + boolean present_tblName = true && (isSetTblName()); + list.add(present_tblName); + if (present_tblName) + list.add(tblName); + + boolean present_partitionKeys = true && (isSetPartitionKeys()); + list.add(present_partitionKeys); + if (present_partitionKeys) + list.add(partitionKeys); + + boolean present_applyDistinct = true && (isSetApplyDistinct()); + list.add(present_applyDistinct); + if (present_applyDistinct) + list.add(applyDistinct); + + boolean present_filter = true && (isSetFilter()); + list.add(present_filter); + if (present_filter) + list.add(filter); + + boolean present_partitionOrder = true && (isSetPartitionOrder()); + list.add(present_partitionOrder); + if (present_partitionOrder) + list.add(partitionOrder); + + boolean present_ascending = true && (isSetAscending()); + list.add(present_ascending); + if (present_ascending) + list.add(ascending); + + boolean present_maxParts = true && (isSetMaxParts()); + list.add(present_maxParts); + if (present_maxParts) + list.add(maxParts); + + return list.hashCode(); + } + + @Override + public int compareTo(PartitionValuesRequest other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetDbName()).compareTo(other.isSetDbName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDbName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dbName, other.dbName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTblName()).compareTo(other.isSetTblName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTblName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tblName, other.tblName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPartitionKeys()).compareTo(other.isSetPartitionKeys()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartitionKeys()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partitionKeys, other.partitionKeys); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetApplyDistinct()).compareTo(other.isSetApplyDistinct()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetApplyDistinct()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.applyDistinct, other.applyDistinct); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFilter()).compareTo(other.isSetFilter()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFilter()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filter, other.filter); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPartitionOrder()).compareTo(other.isSetPartitionOrder()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartitionOrder()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partitionOrder, other.partitionOrder); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetAscending()).compareTo(other.isSetAscending()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAscending()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ascending, other.ascending); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetMaxParts()).compareTo(other.isSetMaxParts()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMaxParts()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxParts, other.maxParts); + 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("PartitionValuesRequest("); + boolean first = true; + + sb.append("dbName:"); + if (this.dbName == null) { + sb.append("null"); + } else { + sb.append(this.dbName); + } + first = false; + if (!first) sb.append(", "); + sb.append("tblName:"); + if (this.tblName == null) { + sb.append("null"); + } else { + sb.append(this.tblName); + } + first = false; + if (!first) sb.append(", "); + sb.append("partitionKeys:"); + if (this.partitionKeys == null) { + sb.append("null"); + } else { + sb.append(this.partitionKeys); + } + first = false; + if (isSetApplyDistinct()) { + if (!first) sb.append(", "); + sb.append("applyDistinct:"); + sb.append(this.applyDistinct); + first = false; + } + if (isSetFilter()) { + if (!first) sb.append(", "); + sb.append("filter:"); + if (this.filter == null) { + sb.append("null"); + } else { + sb.append(this.filter); + } + first = false; + } + if (isSetPartitionOrder()) { + if (!first) sb.append(", "); + sb.append("partitionOrder:"); + if (this.partitionOrder == null) { + sb.append("null"); + } else { + sb.append(this.partitionOrder); + } + first = false; + } + if (isSetAscending()) { + if (!first) sb.append(", "); + sb.append("ascending:"); + sb.append(this.ascending); + first = false; + } + if (isSetMaxParts()) { + if (!first) sb.append(", "); + sb.append("maxParts:"); + sb.append(this.maxParts); + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetDbName()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'dbName' is unset! Struct:" + toString()); + } + + if (!isSetTblName()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'tblName' is unset! Struct:" + toString()); + } + + if (!isSetPartitionKeys()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'partitionKeys' is unset! Struct:" + toString()); + } + + // 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 PartitionValuesRequestStandardSchemeFactory implements SchemeFactory { + public PartitionValuesRequestStandardScheme getScheme() { + return new PartitionValuesRequestStandardScheme(); + } + } + + private static class PartitionValuesRequestStandardScheme extends StandardScheme<PartitionValuesRequest> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, PartitionValuesRequest 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: // DB_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.dbName = iprot.readString(); + struct.setDbNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // TBL_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.tblName = iprot.readString(); + struct.setTblNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PARTITION_KEYS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list484 = iprot.readListBegin(); + struct.partitionKeys = new ArrayList<FieldSchema>(_list484.size); + FieldSchema _elem485; + for (int _i486 = 0; _i486 < _list484.size; ++_i486) + { + _elem485 = new FieldSchema(); + _elem485.read(iprot); + struct.partitionKeys.add(_elem485); + } + iprot.readListEnd(); + } + struct.setPartitionKeysIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // APPLY_DISTINCT + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.applyDistinct = iprot.readBool(); + struct.setApplyDistinctIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // FILTER + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.filter = iprot.readString(); + struct.setFilterIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // PARTITION_ORDER + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list487 = iprot.readListBegin(); + struct.partitionOrder = new ArrayList<FieldSchema>(_list487.size); + FieldSchema _elem488; + for (int _i489 = 0; _i489 < _list487.size; ++_i489) + { + _elem488 = new FieldSchema(); + _elem488.read(iprot); + struct.partitionOrder.add(_elem488); + } + iprot.readListEnd(); + } + struct.setPartitionOrderIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // ASCENDING + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.ascending = iprot.readBool(); + struct.setAscendingIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // MAX_PARTS + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.maxParts = iprot.readI64(); + struct.setMaxPartsIsSet(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, PartitionValuesRequest struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.dbName != null) { + oprot.writeFieldBegin(DB_NAME_FIELD_DESC); + oprot.writeString(struct.dbName); + oprot.writeFieldEnd(); + } + if (struct.tblName != null) { + oprot.writeFieldBegin(TBL_NAME_FIELD_DESC); + oprot.writeString(struct.tblName); + oprot.writeFieldEnd(); + } + if (struct.partitionKeys != null) { + oprot.writeFieldBegin(PARTITION_KEYS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitionKeys.size())); + for (FieldSchema _iter490 : struct.partitionKeys) + { + _iter490.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.isSetApplyDistinct()) { + oprot.writeFieldBegin(APPLY_DISTINCT_FIELD_DESC); + oprot.writeBool(struct.applyDistinct); + oprot.writeFieldEnd(); + } + if (struct.filter != null) { + if (struct.isSetFilter()) { + oprot.writeFieldBegin(FILTER_FIELD_DESC); + oprot.writeString(struct.filter); + oprot.writeFieldEnd(); + } + } + if (struct.partitionOrder != null) { + if (struct.isSetPartitionOrder()) { + oprot.writeFieldBegin(PARTITION_ORDER_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitionOrder.size())); + for (FieldSchema _iter491 : struct.partitionOrder) + { + _iter491.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } + if (struct.isSetAscending()) { + oprot.writeFieldBegin(ASCENDING_FIELD_DESC); + oprot.writeBool(struct.ascending); + oprot.writeFieldEnd(); + } + if (struct.isSetMaxParts()) { + oprot.writeFieldBegin(MAX_PARTS_FIELD_DESC); + oprot.writeI64(struct.maxParts); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class PartitionValuesRequestTupleSchemeFactory implements SchemeFactory { + public PartitionValuesRequestTupleScheme getScheme() { + return new PartitionValuesRequestTupleScheme(); + } + } + + private static class PartitionValuesRequestTupleScheme extends TupleScheme<PartitionValuesRequest> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, PartitionValuesRequest struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + oprot.writeString(struct.dbName); + oprot.writeString(struct.tblName); + { + oprot.writeI32(struct.partitionKeys.size()); + for (FieldSchema _iter492 : struct.partitionKeys) + { + _iter492.write(oprot); + } + } + BitSet optionals = new BitSet(); + if (struct.isSetApplyDistinct()) { + optionals.set(0); + } + if (struct.isSetFilter()) { + optionals.set(1); + } + if (struct.isSetPartitionOrder()) { + optionals.set(2); + } + if (struct.isSetAscending()) { + optionals.set(3); + } + if (struct.isSetMaxParts()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetApplyDistinct()) { + oprot.writeBool(struct.applyDistinct); + } + if (struct.isSetFilter()) { + oprot.writeString(struct.filter); + } + if (struct.isSetPartitionOrder()) { + { + oprot.writeI32(struct.partitionOrder.size()); + for (FieldSchema _iter493 : struct.partitionOrder) + { + _iter493.write(oprot); + } + } + } + if (struct.isSetAscending()) { + oprot.writeBool(struct.ascending); + } + if (struct.isSetMaxParts()) { + oprot.writeI64(struct.maxParts); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, PartitionValuesRequest struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + struct.dbName = iprot.readString(); + struct.setDbNameIsSet(true); + struct.tblName = iprot.readString(); + struct.setTblNameIsSet(true); + { + org.apache.thrift.protocol.TList _list494 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.partitionKeys = new ArrayList<FieldSchema>(_list494.size); + FieldSchema _elem495; + for (int _i496 = 0; _i496 < _list494.size; ++_i496) + { + _elem495 = new FieldSchema(); + _elem495.read(iprot); + struct.partitionKeys.add(_elem495); + } + } + struct.setPartitionKeysIsSet(true); + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.applyDistinct = iprot.readBool(); + struct.setApplyDistinctIsSet(true); + } + if (incoming.get(1)) { + struct.filter = iprot.readString(); + struct.setFilterIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list497 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.partitionOrder = new ArrayList<FieldSchema>(_list497.size); + FieldSchema _elem498; + for (int _i499 = 0; _i499 < _list497.size; ++_i499) + { + _elem498 = new FieldSchema(); + _elem498.read(iprot); + struct.partitionOrder.add(_elem498); + } + } + struct.setPartitionOrderIsSet(true); + } + if (incoming.get(3)) { + struct.ascending = iprot.readBool(); + struct.setAscendingIsSet(true); + } + if (incoming.get(4)) { + struct.maxParts = iprot.readI64(); + struct.setMaxPartsIsSet(true); + } + } + } + +} + http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesResponse.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesResponse.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesResponse.java new file mode 100644 index 0000000..69be7cd --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesResponse.java @@ -0,0 +1,443 @@ +/** + * 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)") +public class PartitionValuesResponse implements org.apache.thrift.TBase<PartitionValuesResponse, PartitionValuesResponse._Fields>, java.io.Serializable, Cloneable, Comparable<PartitionValuesResponse> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionValuesResponse"); + + private static final org.apache.thrift.protocol.TField PARTITION_VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("partitionValues", 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 PartitionValuesResponseStandardSchemeFactory()); + schemes.put(TupleScheme.class, new PartitionValuesResponseTupleSchemeFactory()); + } + + private List<PartitionValuesRow> partitionValues; // 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 { + PARTITION_VALUES((short)1, "partitionValues"); + + 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: // PARTITION_VALUES + return PARTITION_VALUES; + 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.PARTITION_VALUES, new org.apache.thrift.meta_data.FieldMetaData("partitionValues", org.apache.thrift.TFieldRequirementType.REQUIRED, + 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, PartitionValuesRow.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PartitionValuesResponse.class, metaDataMap); + } + + public PartitionValuesResponse() { + } + + public PartitionValuesResponse( + List<PartitionValuesRow> partitionValues) + { + this(); + this.partitionValues = partitionValues; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public PartitionValuesResponse(PartitionValuesResponse other) { + if (other.isSetPartitionValues()) { + List<PartitionValuesRow> __this__partitionValues = new ArrayList<PartitionValuesRow>(other.partitionValues.size()); + for (PartitionValuesRow other_element : other.partitionValues) { + __this__partitionValues.add(new PartitionValuesRow(other_element)); + } + this.partitionValues = __this__partitionValues; + } + } + + public PartitionValuesResponse deepCopy() { + return new PartitionValuesResponse(this); + } + + @Override + public void clear() { + this.partitionValues = null; + } + + public int getPartitionValuesSize() { + return (this.partitionValues == null) ? 0 : this.partitionValues.size(); + } + + public java.util.Iterator<PartitionValuesRow> getPartitionValuesIterator() { + return (this.partitionValues == null) ? null : this.partitionValues.iterator(); + } + + public void addToPartitionValues(PartitionValuesRow elem) { + if (this.partitionValues == null) { + this.partitionValues = new ArrayList<PartitionValuesRow>(); + } + this.partitionValues.add(elem); + } + + public List<PartitionValuesRow> getPartitionValues() { + return this.partitionValues; + } + + public void setPartitionValues(List<PartitionValuesRow> partitionValues) { + this.partitionValues = partitionValues; + } + + public void unsetPartitionValues() { + this.partitionValues = null; + } + + /** Returns true if field partitionValues is set (has been assigned a value) and false otherwise */ + public boolean isSetPartitionValues() { + return this.partitionValues != null; + } + + public void setPartitionValuesIsSet(boolean value) { + if (!value) { + this.partitionValues = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PARTITION_VALUES: + if (value == null) { + unsetPartitionValues(); + } else { + setPartitionValues((List<PartitionValuesRow>)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PARTITION_VALUES: + return getPartitionValues(); + + } + 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 PARTITION_VALUES: + return isSetPartitionValues(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof PartitionValuesResponse) + return this.equals((PartitionValuesResponse)that); + return false; + } + + public boolean equals(PartitionValuesResponse that) { + if (that == null) + return false; + + boolean this_present_partitionValues = true && this.isSetPartitionValues(); + boolean that_present_partitionValues = true && that.isSetPartitionValues(); + if (this_present_partitionValues || that_present_partitionValues) { + if (!(this_present_partitionValues && that_present_partitionValues)) + return false; + if (!this.partitionValues.equals(that.partitionValues)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_partitionValues = true && (isSetPartitionValues()); + list.add(present_partitionValues); + if (present_partitionValues) + list.add(partitionValues); + + return list.hashCode(); + } + + @Override + public int compareTo(PartitionValuesResponse other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPartitionValues()).compareTo(other.isSetPartitionValues()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPartitionValues()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.partitionValues, other.partitionValues); + 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("PartitionValuesResponse("); + boolean first = true; + + sb.append("partitionValues:"); + if (this.partitionValues == null) { + sb.append("null"); + } else { + sb.append(this.partitionValues); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetPartitionValues()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'partitionValues' is unset! Struct:" + toString()); + } + + // 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 PartitionValuesResponseStandardSchemeFactory implements SchemeFactory { + public PartitionValuesResponseStandardScheme getScheme() { + return new PartitionValuesResponseStandardScheme(); + } + } + + private static class PartitionValuesResponseStandardScheme extends StandardScheme<PartitionValuesResponse> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, PartitionValuesResponse 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: // PARTITION_VALUES + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list508 = iprot.readListBegin(); + struct.partitionValues = new ArrayList<PartitionValuesRow>(_list508.size); + PartitionValuesRow _elem509; + for (int _i510 = 0; _i510 < _list508.size; ++_i510) + { + _elem509 = new PartitionValuesRow(); + _elem509.read(iprot); + struct.partitionValues.add(_elem509); + } + iprot.readListEnd(); + } + struct.setPartitionValuesIsSet(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, PartitionValuesResponse struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.partitionValues != null) { + oprot.writeFieldBegin(PARTITION_VALUES_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.partitionValues.size())); + for (PartitionValuesRow _iter511 : struct.partitionValues) + { + _iter511.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class PartitionValuesResponseTupleSchemeFactory implements SchemeFactory { + public PartitionValuesResponseTupleScheme getScheme() { + return new PartitionValuesResponseTupleScheme(); + } + } + + private static class PartitionValuesResponseTupleScheme extends TupleScheme<PartitionValuesResponse> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, PartitionValuesResponse struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + { + oprot.writeI32(struct.partitionValues.size()); + for (PartitionValuesRow _iter512 : struct.partitionValues) + { + _iter512.write(oprot); + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, PartitionValuesResponse struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + { + org.apache.thrift.protocol.TList _list513 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.partitionValues = new ArrayList<PartitionValuesRow>(_list513.size); + PartitionValuesRow _elem514; + for (int _i515 = 0; _i515 < _list513.size; ++_i515) + { + _elem514 = new PartitionValuesRow(); + _elem514.read(iprot); + struct.partitionValues.add(_elem514); + } + } + struct.setPartitionValuesIsSet(true); + } + } + +} + http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRow.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRow.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRow.java new file mode 100644 index 0000000..2ed8014 --- /dev/null +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionValuesRow.java @@ -0,0 +1,438 @@ +/** + * 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)") +public class PartitionValuesRow implements org.apache.thrift.TBase<PartitionValuesRow, PartitionValuesRow._Fields>, java.io.Serializable, Cloneable, Comparable<PartitionValuesRow> { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionValuesRow"); + + private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", 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 PartitionValuesRowStandardSchemeFactory()); + schemes.put(TupleScheme.class, new PartitionValuesRowTupleSchemeFactory()); + } + + private List<String> row; // 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 { + ROW((short)1, "row"); + + 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: // ROW + return ROW; + 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.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.REQUIRED, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PartitionValuesRow.class, metaDataMap); + } + + public PartitionValuesRow() { + } + + public PartitionValuesRow( + List<String> row) + { + this(); + this.row = row; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public PartitionValuesRow(PartitionValuesRow other) { + if (other.isSetRow()) { + List<String> __this__row = new ArrayList<String>(other.row); + this.row = __this__row; + } + } + + public PartitionValuesRow deepCopy() { + return new PartitionValuesRow(this); + } + + @Override + public void clear() { + this.row = null; + } + + public int getRowSize() { + return (this.row == null) ? 0 : this.row.size(); + } + + public java.util.Iterator<String> getRowIterator() { + return (this.row == null) ? null : this.row.iterator(); + } + + public void addToRow(String elem) { + if (this.row == null) { + this.row = new ArrayList<String>(); + } + this.row.add(elem); + } + + public List<String> getRow() { + return this.row; + } + + public void setRow(List<String> row) { + this.row = row; + } + + public void unsetRow() { + this.row = null; + } + + /** Returns true if field row is set (has been assigned a value) and false otherwise */ + public boolean isSetRow() { + return this.row != null; + } + + public void setRowIsSet(boolean value) { + if (!value) { + this.row = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case ROW: + if (value == null) { + unsetRow(); + } else { + setRow((List<String>)value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case ROW: + return getRow(); + + } + 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 ROW: + return isSetRow(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof PartitionValuesRow) + return this.equals((PartitionValuesRow)that); + return false; + } + + public boolean equals(PartitionValuesRow that) { + if (that == null) + return false; + + boolean this_present_row = true && this.isSetRow(); + boolean that_present_row = true && that.isSetRow(); + if (this_present_row || that_present_row) { + if (!(this_present_row && that_present_row)) + return false; + if (!this.row.equals(that.row)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_row = true && (isSetRow()); + list.add(present_row); + if (present_row) + list.add(row); + + return list.hashCode(); + } + + @Override + public int compareTo(PartitionValuesRow other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRow()).compareTo(other.isSetRow()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRow()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, other.row); + 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("PartitionValuesRow("); + boolean first = true; + + sb.append("row:"); + if (this.row == null) { + sb.append("null"); + } else { + sb.append(this.row); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + if (!isSetRow()) { + throw new org.apache.thrift.protocol.TProtocolException("Required field 'row' is unset! Struct:" + toString()); + } + + // 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 PartitionValuesRowStandardSchemeFactory implements SchemeFactory { + public PartitionValuesRowStandardScheme getScheme() { + return new PartitionValuesRowStandardScheme(); + } + } + + private static class PartitionValuesRowStandardScheme extends StandardScheme<PartitionValuesRow> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, PartitionValuesRow 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: // ROW + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list500 = iprot.readListBegin(); + struct.row = new ArrayList<String>(_list500.size); + String _elem501; + for (int _i502 = 0; _i502 < _list500.size; ++_i502) + { + _elem501 = iprot.readString(); + struct.row.add(_elem501); + } + iprot.readListEnd(); + } + struct.setRowIsSet(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, PartitionValuesRow struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.row != null) { + oprot.writeFieldBegin(ROW_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.row.size())); + for (String _iter503 : struct.row) + { + oprot.writeString(_iter503); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class PartitionValuesRowTupleSchemeFactory implements SchemeFactory { + public PartitionValuesRowTupleScheme getScheme() { + return new PartitionValuesRowTupleScheme(); + } + } + + private static class PartitionValuesRowTupleScheme extends TupleScheme<PartitionValuesRow> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, PartitionValuesRow struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + { + oprot.writeI32(struct.row.size()); + for (String _iter504 : struct.row) + { + oprot.writeString(_iter504); + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, PartitionValuesRow struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + { + org.apache.thrift.protocol.TList _list505 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.row = new ArrayList<String>(_list505.size); + String _elem506; + for (int _i507 = 0; _i507 < _list505.size; ++_i507) + { + _elem506 = iprot.readString(); + struct.row.add(_elem506); + } + } + struct.setRowIsSet(true); + } + } + +} + http://git-wip-us.apache.org/repos/asf/hive/blob/9a149843/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java index 0c06ff3..d4b7d8c 100644 --- a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java +++ b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PutFileMetadataRequest.java @@ -547,13 +547,13 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe case 1: // FILE_IDS if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list650 = iprot.readListBegin(); - struct.fileIds = new ArrayList<Long>(_list650.size); - long _elem651; - for (int _i652 = 0; _i652 < _list650.size; ++_i652) + org.apache.thrift.protocol.TList _list682 = iprot.readListBegin(); + struct.fileIds = new ArrayList<Long>(_list682.size); + long _elem683; + for (int _i684 = 0; _i684 < _list682.size; ++_i684) { - _elem651 = iprot.readI64(); - struct.fileIds.add(_elem651); + _elem683 = iprot.readI64(); + struct.fileIds.add(_elem683); } iprot.readListEnd(); } @@ -565,13 +565,13 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe case 2: // METADATA if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { { - org.apache.thrift.protocol.TList _list653 = iprot.readListBegin(); - struct.metadata = new ArrayList<ByteBuffer>(_list653.size); - ByteBuffer _elem654; - for (int _i655 = 0; _i655 < _list653.size; ++_i655) + org.apache.thrift.protocol.TList _list685 = iprot.readListBegin(); + struct.metadata = new ArrayList<ByteBuffer>(_list685.size); + ByteBuffer _elem686; + for (int _i687 = 0; _i687 < _list685.size; ++_i687) { - _elem654 = iprot.readBinary(); - struct.metadata.add(_elem654); + _elem686 = iprot.readBinary(); + struct.metadata.add(_elem686); } iprot.readListEnd(); } @@ -605,9 +605,9 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe oprot.writeFieldBegin(FILE_IDS_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, struct.fileIds.size())); - for (long _iter656 : struct.fileIds) + for (long _iter688 : struct.fileIds) { - oprot.writeI64(_iter656); + oprot.writeI64(_iter688); } oprot.writeListEnd(); } @@ -617,9 +617,9 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe oprot.writeFieldBegin(METADATA_FIELD_DESC); { oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.metadata.size())); - for (ByteBuffer _iter657 : struct.metadata) + for (ByteBuffer _iter689 : struct.metadata) { - oprot.writeBinary(_iter657); + oprot.writeBinary(_iter689); } oprot.writeListEnd(); } @@ -651,16 +651,16 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe TTupleProtocol oprot = (TTupleProtocol) prot; { oprot.writeI32(struct.fileIds.size()); - for (long _iter658 : struct.fileIds) + for (long _iter690 : struct.fileIds) { - oprot.writeI64(_iter658); + oprot.writeI64(_iter690); } } { oprot.writeI32(struct.metadata.size()); - for (ByteBuffer _iter659 : struct.metadata) + for (ByteBuffer _iter691 : struct.metadata) { - oprot.writeBinary(_iter659); + oprot.writeBinary(_iter691); } } BitSet optionals = new BitSet(); @@ -677,24 +677,24 @@ public class PutFileMetadataRequest implements org.apache.thrift.TBase<PutFileMe public void read(org.apache.thrift.protocol.TProtocol prot, PutFileMetadataRequest struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { - org.apache.thrift.protocol.TList _list660 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); - struct.fileIds = new ArrayList<Long>(_list660.size); - long _elem661; - for (int _i662 = 0; _i662 < _list660.size; ++_i662) + org.apache.thrift.protocol.TList _list692 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, iprot.readI32()); + struct.fileIds = new ArrayList<Long>(_list692.size); + long _elem693; + for (int _i694 = 0; _i694 < _list692.size; ++_i694) { - _elem661 = iprot.readI64(); - struct.fileIds.add(_elem661); + _elem693 = iprot.readI64(); + struct.fileIds.add(_elem693); } } struct.setFileIdsIsSet(true); { - org.apache.thrift.protocol.TList _list663 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.metadata = new ArrayList<ByteBuffer>(_list663.size); - ByteBuffer _elem664; - for (int _i665 = 0; _i665 < _list663.size; ++_i665) + org.apache.thrift.protocol.TList _list695 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.metadata = new ArrayList<ByteBuffer>(_list695.size); + ByteBuffer _elem696; + for (int _i697 = 0; _i697 < _list695.size; ++_i697) { - _elem664 = iprot.readBinary(); - struct.metadata.add(_elem664); + _elem696 = iprot.readBinary(); + struct.metadata.add(_elem696); } } struct.setMetadataIsSet(true);
