http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/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 4bdca8c..e4089c5 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 @@ import org.slf4j.LoggerFactory;
           case 1: // FILE_IDS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list690 = 
iprot.readListBegin();
-                struct.fileIds = new ArrayList<Long>(_list690.size);
-                long _elem691;
-                for (int _i692 = 0; _i692 < _list690.size; ++_i692)
+                org.apache.thrift.protocol.TList _list730 = 
iprot.readListBegin();
+                struct.fileIds = new ArrayList<Long>(_list730.size);
+                long _elem731;
+                for (int _i732 = 0; _i732 < _list730.size; ++_i732)
                 {
-                  _elem691 = iprot.readI64();
-                  struct.fileIds.add(_elem691);
+                  _elem731 = iprot.readI64();
+                  struct.fileIds.add(_elem731);
                 }
                 iprot.readListEnd();
               }
@@ -565,13 +565,13 @@ import org.slf4j.LoggerFactory;
           case 2: // METADATA
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list693 = 
iprot.readListBegin();
-                struct.metadata = new ArrayList<ByteBuffer>(_list693.size);
-                ByteBuffer _elem694;
-                for (int _i695 = 0; _i695 < _list693.size; ++_i695)
+                org.apache.thrift.protocol.TList _list733 = 
iprot.readListBegin();
+                struct.metadata = new ArrayList<ByteBuffer>(_list733.size);
+                ByteBuffer _elem734;
+                for (int _i735 = 0; _i735 < _list733.size; ++_i735)
                 {
-                  _elem694 = iprot.readBinary();
-                  struct.metadata.add(_elem694);
+                  _elem734 = iprot.readBinary();
+                  struct.metadata.add(_elem734);
                 }
                 iprot.readListEnd();
               }
@@ -605,9 +605,9 @@ import org.slf4j.LoggerFactory;
         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 _iter696 : struct.fileIds)
+          for (long _iter736 : struct.fileIds)
           {
-            oprot.writeI64(_iter696);
+            oprot.writeI64(_iter736);
           }
           oprot.writeListEnd();
         }
@@ -617,9 +617,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(METADATA_FIELD_DESC);
         {
           oprot.writeListBegin(new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, 
struct.metadata.size()));
-          for (ByteBuffer _iter697 : struct.metadata)
+          for (ByteBuffer _iter737 : struct.metadata)
           {
-            oprot.writeBinary(_iter697);
+            oprot.writeBinary(_iter737);
           }
           oprot.writeListEnd();
         }
@@ -651,16 +651,16 @@ import org.slf4j.LoggerFactory;
       TTupleProtocol oprot = (TTupleProtocol) prot;
       {
         oprot.writeI32(struct.fileIds.size());
-        for (long _iter698 : struct.fileIds)
+        for (long _iter738 : struct.fileIds)
         {
-          oprot.writeI64(_iter698);
+          oprot.writeI64(_iter738);
         }
       }
       {
         oprot.writeI32(struct.metadata.size());
-        for (ByteBuffer _iter699 : struct.metadata)
+        for (ByteBuffer _iter739 : struct.metadata)
         {
-          oprot.writeBinary(_iter699);
+          oprot.writeBinary(_iter739);
         }
       }
       BitSet optionals = new BitSet();
@@ -677,24 +677,24 @@ import org.slf4j.LoggerFactory;
     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 _list700 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, 
iprot.readI32());
-        struct.fileIds = new ArrayList<Long>(_list700.size);
-        long _elem701;
-        for (int _i702 = 0; _i702 < _list700.size; ++_i702)
+        org.apache.thrift.protocol.TList _list740 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, 
iprot.readI32());
+        struct.fileIds = new ArrayList<Long>(_list740.size);
+        long _elem741;
+        for (int _i742 = 0; _i742 < _list740.size; ++_i742)
         {
-          _elem701 = iprot.readI64();
-          struct.fileIds.add(_elem701);
+          _elem741 = iprot.readI64();
+          struct.fileIds.add(_elem741);
         }
       }
       struct.setFileIdsIsSet(true);
       {
-        org.apache.thrift.protocol.TList _list703 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, 
iprot.readI32());
-        struct.metadata = new ArrayList<ByteBuffer>(_list703.size);
-        ByteBuffer _elem704;
-        for (int _i705 = 0; _i705 < _list703.size; ++_i705)
+        org.apache.thrift.protocol.TList _list743 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, 
iprot.readI32());
+        struct.metadata = new ArrayList<ByteBuffer>(_list743.size);
+        ByteBuffer _elem744;
+        for (int _i745 = 0; _i745 < _list743.size; ++_i745)
         {
-          _elem704 = iprot.readBinary();
-          struct.metadata.add(_elem704);
+          _elem744 = iprot.readBinary();
+          struct.metadata.add(_elem744);
         }
       }
       struct.setMetadataIsSet(true);

http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java
 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java
index 5687b19..fb7b94e 100644
--- 
a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java
+++ 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowCompactResponse.java
@@ -354,14 +354,14 @@ import org.slf4j.LoggerFactory;
           case 1: // COMPACTS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list598 = 
iprot.readListBegin();
-                struct.compacts = new 
ArrayList<ShowCompactResponseElement>(_list598.size);
-                ShowCompactResponseElement _elem599;
-                for (int _i600 = 0; _i600 < _list598.size; ++_i600)
+                org.apache.thrift.protocol.TList _list638 = 
iprot.readListBegin();
+                struct.compacts = new 
ArrayList<ShowCompactResponseElement>(_list638.size);
+                ShowCompactResponseElement _elem639;
+                for (int _i640 = 0; _i640 < _list638.size; ++_i640)
                 {
-                  _elem599 = new ShowCompactResponseElement();
-                  _elem599.read(iprot);
-                  struct.compacts.add(_elem599);
+                  _elem639 = new ShowCompactResponseElement();
+                  _elem639.read(iprot);
+                  struct.compacts.add(_elem639);
                 }
                 iprot.readListEnd();
               }
@@ -387,9 +387,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(COMPACTS_FIELD_DESC);
         {
           oprot.writeListBegin(new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
struct.compacts.size()));
-          for (ShowCompactResponseElement _iter601 : struct.compacts)
+          for (ShowCompactResponseElement _iter641 : struct.compacts)
           {
-            _iter601.write(oprot);
+            _iter641.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -414,9 +414,9 @@ import org.slf4j.LoggerFactory;
       TTupleProtocol oprot = (TTupleProtocol) prot;
       {
         oprot.writeI32(struct.compacts.size());
-        for (ShowCompactResponseElement _iter602 : struct.compacts)
+        for (ShowCompactResponseElement _iter642 : struct.compacts)
         {
-          _iter602.write(oprot);
+          _iter642.write(oprot);
         }
       }
     }
@@ -425,14 +425,14 @@ import org.slf4j.LoggerFactory;
     public void read(org.apache.thrift.protocol.TProtocol prot, 
ShowCompactResponse struct) throws org.apache.thrift.TException {
       TTupleProtocol iprot = (TTupleProtocol) prot;
       {
-        org.apache.thrift.protocol.TList _list603 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
iprot.readI32());
-        struct.compacts = new 
ArrayList<ShowCompactResponseElement>(_list603.size);
-        ShowCompactResponseElement _elem604;
-        for (int _i605 = 0; _i605 < _list603.size; ++_i605)
+        org.apache.thrift.protocol.TList _list643 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
iprot.readI32());
+        struct.compacts = new 
ArrayList<ShowCompactResponseElement>(_list643.size);
+        ShowCompactResponseElement _elem644;
+        for (int _i645 = 0; _i645 < _list643.size; ++_i645)
         {
-          _elem604 = new ShowCompactResponseElement();
-          _elem604.read(iprot);
-          struct.compacts.add(_elem604);
+          _elem644 = new ShowCompactResponseElement();
+          _elem644.read(iprot);
+          struct.compacts.add(_elem644);
         }
       }
       struct.setCompactsIsSet(true);

http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java
 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java
index f22deb2..02dd278 100644
--- 
a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java
+++ 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ShowLocksResponse.java
@@ -350,14 +350,14 @@ import org.slf4j.LoggerFactory;
           case 1: // LOCKS
             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TList _list564 = 
iprot.readListBegin();
-                struct.locks = new 
ArrayList<ShowLocksResponseElement>(_list564.size);
-                ShowLocksResponseElement _elem565;
-                for (int _i566 = 0; _i566 < _list564.size; ++_i566)
+                org.apache.thrift.protocol.TList _list604 = 
iprot.readListBegin();
+                struct.locks = new 
ArrayList<ShowLocksResponseElement>(_list604.size);
+                ShowLocksResponseElement _elem605;
+                for (int _i606 = 0; _i606 < _list604.size; ++_i606)
                 {
-                  _elem565 = new ShowLocksResponseElement();
-                  _elem565.read(iprot);
-                  struct.locks.add(_elem565);
+                  _elem605 = new ShowLocksResponseElement();
+                  _elem605.read(iprot);
+                  struct.locks.add(_elem605);
                 }
                 iprot.readListEnd();
               }
@@ -383,9 +383,9 @@ import org.slf4j.LoggerFactory;
         oprot.writeFieldBegin(LOCKS_FIELD_DESC);
         {
           oprot.writeListBegin(new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
struct.locks.size()));
-          for (ShowLocksResponseElement _iter567 : struct.locks)
+          for (ShowLocksResponseElement _iter607 : struct.locks)
           {
-            _iter567.write(oprot);
+            _iter607.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -416,9 +416,9 @@ import org.slf4j.LoggerFactory;
       if (struct.isSetLocks()) {
         {
           oprot.writeI32(struct.locks.size());
-          for (ShowLocksResponseElement _iter568 : struct.locks)
+          for (ShowLocksResponseElement _iter608 : struct.locks)
           {
-            _iter568.write(oprot);
+            _iter608.write(oprot);
           }
         }
       }
@@ -430,14 +430,14 @@ import org.slf4j.LoggerFactory;
       BitSet incoming = iprot.readBitSet(1);
       if (incoming.get(0)) {
         {
-          org.apache.thrift.protocol.TList _list569 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
iprot.readI32());
-          struct.locks = new 
ArrayList<ShowLocksResponseElement>(_list569.size);
-          ShowLocksResponseElement _elem570;
-          for (int _i571 = 0; _i571 < _list569.size; ++_i571)
+          org.apache.thrift.protocol.TList _list609 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, 
iprot.readI32());
+          struct.locks = new 
ArrayList<ShowLocksResponseElement>(_list609.size);
+          ShowLocksResponseElement _elem610;
+          for (int _i611 = 0; _i611 < _list609.size; ++_i611)
           {
-            _elem570 = new ShowLocksResponseElement();
-            _elem570.read(iprot);
-            struct.locks.add(_elem570);
+            _elem610 = new ShowLocksResponseElement();
+            _elem610.read(iprot);
+            struct.locks.add(_elem610);
           }
         }
         struct.setLocksIsSet(true);

http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java
 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java
new file mode 100644
index 0000000..1d43fb8
--- /dev/null
+++ 
b/standalone-metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/TableValidWriteIds.java
@@ -0,0 +1,851 @@
+/**
+ * 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 
TableValidWriteIds implements org.apache.thrift.TBase<TableValidWriteIds, 
TableValidWriteIds._Fields>, java.io.Serializable, Cloneable, 
Comparable<TableValidWriteIds> {
+  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new 
org.apache.thrift.protocol.TStruct("TableValidWriteIds");
+
+  private static final org.apache.thrift.protocol.TField 
FULL_TABLE_NAME_FIELD_DESC = new 
org.apache.thrift.protocol.TField("fullTableName", 
org.apache.thrift.protocol.TType.STRING, (short)1);
+  private static final org.apache.thrift.protocol.TField 
WRITE_ID_HIGH_WATER_MARK_FIELD_DESC = new 
org.apache.thrift.protocol.TField("writeIdHighWaterMark", 
org.apache.thrift.protocol.TType.I64, (short)2);
+  private static final org.apache.thrift.protocol.TField 
INVALID_WRITE_IDS_FIELD_DESC = new 
org.apache.thrift.protocol.TField("invalidWriteIds", 
org.apache.thrift.protocol.TType.LIST, (short)3);
+  private static final org.apache.thrift.protocol.TField 
MIN_OPEN_WRITE_ID_FIELD_DESC = new 
org.apache.thrift.protocol.TField("minOpenWriteId", 
org.apache.thrift.protocol.TType.I64, (short)4);
+  private static final org.apache.thrift.protocol.TField 
ABORTED_BITS_FIELD_DESC = new org.apache.thrift.protocol.TField("abortedBits", 
org.apache.thrift.protocol.TType.STRING, (short)5);
+
+  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = 
new HashMap<Class<? extends IScheme>, SchemeFactory>();
+  static {
+    schemes.put(StandardScheme.class, new 
TableValidWriteIdsStandardSchemeFactory());
+    schemes.put(TupleScheme.class, new TableValidWriteIdsTupleSchemeFactory());
+  }
+
+  private String fullTableName; // required
+  private long writeIdHighWaterMark; // required
+  private List<Long> invalidWriteIds; // required
+  private long minOpenWriteId; // optional
+  private ByteBuffer abortedBits; // 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 {
+    FULL_TABLE_NAME((short)1, "fullTableName"),
+    WRITE_ID_HIGH_WATER_MARK((short)2, "writeIdHighWaterMark"),
+    INVALID_WRITE_IDS((short)3, "invalidWriteIds"),
+    MIN_OPEN_WRITE_ID((short)4, "minOpenWriteId"),
+    ABORTED_BITS((short)5, "abortedBits");
+
+    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: // FULL_TABLE_NAME
+          return FULL_TABLE_NAME;
+        case 2: // WRITE_ID_HIGH_WATER_MARK
+          return WRITE_ID_HIGH_WATER_MARK;
+        case 3: // INVALID_WRITE_IDS
+          return INVALID_WRITE_IDS;
+        case 4: // MIN_OPEN_WRITE_ID
+          return MIN_OPEN_WRITE_ID;
+        case 5: // ABORTED_BITS
+          return ABORTED_BITS;
+        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 __WRITEIDHIGHWATERMARK_ISSET_ID = 0;
+  private static final int __MINOPENWRITEID_ISSET_ID = 1;
+  private byte __isset_bitfield = 0;
+  private static final _Fields optionals[] = {_Fields.MIN_OPEN_WRITE_ID};
+  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.FULL_TABLE_NAME, new 
org.apache.thrift.meta_data.FieldMetaData("fullTableName", 
org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new 
org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
+    tmpMap.put(_Fields.WRITE_ID_HIGH_WATER_MARK, new 
org.apache.thrift.meta_data.FieldMetaData("writeIdHighWaterMark", 
org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new 
org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.INVALID_WRITE_IDS, new 
org.apache.thrift.meta_data.FieldMetaData("invalidWriteIds", 
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.I64))));
+    tmpMap.put(_Fields.MIN_OPEN_WRITE_ID, new 
org.apache.thrift.meta_data.FieldMetaData("minOpenWriteId", 
org.apache.thrift.TFieldRequirementType.OPTIONAL, 
+        new 
org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+    tmpMap.put(_Fields.ABORTED_BITS, new 
org.apache.thrift.meta_data.FieldMetaData("abortedBits", 
org.apache.thrift.TFieldRequirementType.REQUIRED, 
+        new 
org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING
        , true)));
+    metaDataMap = Collections.unmodifiableMap(tmpMap);
+    
org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TableValidWriteIds.class,
 metaDataMap);
+  }
+
+  public TableValidWriteIds() {
+  }
+
+  public TableValidWriteIds(
+    String fullTableName,
+    long writeIdHighWaterMark,
+    List<Long> invalidWriteIds,
+    ByteBuffer abortedBits)
+  {
+    this();
+    this.fullTableName = fullTableName;
+    this.writeIdHighWaterMark = writeIdHighWaterMark;
+    setWriteIdHighWaterMarkIsSet(true);
+    this.invalidWriteIds = invalidWriteIds;
+    this.abortedBits = org.apache.thrift.TBaseHelper.copyBinary(abortedBits);
+  }
+
+  /**
+   * Performs a deep copy on <i>other</i>.
+   */
+  public TableValidWriteIds(TableValidWriteIds other) {
+    __isset_bitfield = other.__isset_bitfield;
+    if (other.isSetFullTableName()) {
+      this.fullTableName = other.fullTableName;
+    }
+    this.writeIdHighWaterMark = other.writeIdHighWaterMark;
+    if (other.isSetInvalidWriteIds()) {
+      List<Long> __this__invalidWriteIds = new 
ArrayList<Long>(other.invalidWriteIds);
+      this.invalidWriteIds = __this__invalidWriteIds;
+    }
+    this.minOpenWriteId = other.minOpenWriteId;
+    if (other.isSetAbortedBits()) {
+      this.abortedBits = 
org.apache.thrift.TBaseHelper.copyBinary(other.abortedBits);
+    }
+  }
+
+  public TableValidWriteIds deepCopy() {
+    return new TableValidWriteIds(this);
+  }
+
+  @Override
+  public void clear() {
+    this.fullTableName = null;
+    setWriteIdHighWaterMarkIsSet(false);
+    this.writeIdHighWaterMark = 0;
+    this.invalidWriteIds = null;
+    setMinOpenWriteIdIsSet(false);
+    this.minOpenWriteId = 0;
+    this.abortedBits = null;
+  }
+
+  public String getFullTableName() {
+    return this.fullTableName;
+  }
+
+  public void setFullTableName(String fullTableName) {
+    this.fullTableName = fullTableName;
+  }
+
+  public void unsetFullTableName() {
+    this.fullTableName = null;
+  }
+
+  /** Returns true if field fullTableName is set (has been assigned a value) 
and false otherwise */
+  public boolean isSetFullTableName() {
+    return this.fullTableName != null;
+  }
+
+  public void setFullTableNameIsSet(boolean value) {
+    if (!value) {
+      this.fullTableName = null;
+    }
+  }
+
+  public long getWriteIdHighWaterMark() {
+    return this.writeIdHighWaterMark;
+  }
+
+  public void setWriteIdHighWaterMark(long writeIdHighWaterMark) {
+    this.writeIdHighWaterMark = writeIdHighWaterMark;
+    setWriteIdHighWaterMarkIsSet(true);
+  }
+
+  public void unsetWriteIdHighWaterMark() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, 
__WRITEIDHIGHWATERMARK_ISSET_ID);
+  }
+
+  /** Returns true if field writeIdHighWaterMark is set (has been assigned a 
value) and false otherwise */
+  public boolean isSetWriteIdHighWaterMark() {
+    return EncodingUtils.testBit(__isset_bitfield, 
__WRITEIDHIGHWATERMARK_ISSET_ID);
+  }
+
+  public void setWriteIdHighWaterMarkIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, 
__WRITEIDHIGHWATERMARK_ISSET_ID, value);
+  }
+
+  public int getInvalidWriteIdsSize() {
+    return (this.invalidWriteIds == null) ? 0 : this.invalidWriteIds.size();
+  }
+
+  public java.util.Iterator<Long> getInvalidWriteIdsIterator() {
+    return (this.invalidWriteIds == null) ? null : 
this.invalidWriteIds.iterator();
+  }
+
+  public void addToInvalidWriteIds(long elem) {
+    if (this.invalidWriteIds == null) {
+      this.invalidWriteIds = new ArrayList<Long>();
+    }
+    this.invalidWriteIds.add(elem);
+  }
+
+  public List<Long> getInvalidWriteIds() {
+    return this.invalidWriteIds;
+  }
+
+  public void setInvalidWriteIds(List<Long> invalidWriteIds) {
+    this.invalidWriteIds = invalidWriteIds;
+  }
+
+  public void unsetInvalidWriteIds() {
+    this.invalidWriteIds = null;
+  }
+
+  /** Returns true if field invalidWriteIds is set (has been assigned a value) 
and false otherwise */
+  public boolean isSetInvalidWriteIds() {
+    return this.invalidWriteIds != null;
+  }
+
+  public void setInvalidWriteIdsIsSet(boolean value) {
+    if (!value) {
+      this.invalidWriteIds = null;
+    }
+  }
+
+  public long getMinOpenWriteId() {
+    return this.minOpenWriteId;
+  }
+
+  public void setMinOpenWriteId(long minOpenWriteId) {
+    this.minOpenWriteId = minOpenWriteId;
+    setMinOpenWriteIdIsSet(true);
+  }
+
+  public void unsetMinOpenWriteId() {
+    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, 
__MINOPENWRITEID_ISSET_ID);
+  }
+
+  /** Returns true if field minOpenWriteId is set (has been assigned a value) 
and false otherwise */
+  public boolean isSetMinOpenWriteId() {
+    return EncodingUtils.testBit(__isset_bitfield, __MINOPENWRITEID_ISSET_ID);
+  }
+
+  public void setMinOpenWriteIdIsSet(boolean value) {
+    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, 
__MINOPENWRITEID_ISSET_ID, value);
+  }
+
+  public byte[] getAbortedBits() {
+    setAbortedBits(org.apache.thrift.TBaseHelper.rightSize(abortedBits));
+    return abortedBits == null ? null : abortedBits.array();
+  }
+
+  public ByteBuffer bufferForAbortedBits() {
+    return org.apache.thrift.TBaseHelper.copyBinary(abortedBits);
+  }
+
+  public void setAbortedBits(byte[] abortedBits) {
+    this.abortedBits = abortedBits == null ? (ByteBuffer)null : 
ByteBuffer.wrap(Arrays.copyOf(abortedBits, abortedBits.length));
+  }
+
+  public void setAbortedBits(ByteBuffer abortedBits) {
+    this.abortedBits = org.apache.thrift.TBaseHelper.copyBinary(abortedBits);
+  }
+
+  public void unsetAbortedBits() {
+    this.abortedBits = null;
+  }
+
+  /** Returns true if field abortedBits is set (has been assigned a value) and 
false otherwise */
+  public boolean isSetAbortedBits() {
+    return this.abortedBits != null;
+  }
+
+  public void setAbortedBitsIsSet(boolean value) {
+    if (!value) {
+      this.abortedBits = null;
+    }
+  }
+
+  public void setFieldValue(_Fields field, Object value) {
+    switch (field) {
+    case FULL_TABLE_NAME:
+      if (value == null) {
+        unsetFullTableName();
+      } else {
+        setFullTableName((String)value);
+      }
+      break;
+
+    case WRITE_ID_HIGH_WATER_MARK:
+      if (value == null) {
+        unsetWriteIdHighWaterMark();
+      } else {
+        setWriteIdHighWaterMark((Long)value);
+      }
+      break;
+
+    case INVALID_WRITE_IDS:
+      if (value == null) {
+        unsetInvalidWriteIds();
+      } else {
+        setInvalidWriteIds((List<Long>)value);
+      }
+      break;
+
+    case MIN_OPEN_WRITE_ID:
+      if (value == null) {
+        unsetMinOpenWriteId();
+      } else {
+        setMinOpenWriteId((Long)value);
+      }
+      break;
+
+    case ABORTED_BITS:
+      if (value == null) {
+        unsetAbortedBits();
+      } else {
+        setAbortedBits((ByteBuffer)value);
+      }
+      break;
+
+    }
+  }
+
+  public Object getFieldValue(_Fields field) {
+    switch (field) {
+    case FULL_TABLE_NAME:
+      return getFullTableName();
+
+    case WRITE_ID_HIGH_WATER_MARK:
+      return getWriteIdHighWaterMark();
+
+    case INVALID_WRITE_IDS:
+      return getInvalidWriteIds();
+
+    case MIN_OPEN_WRITE_ID:
+      return getMinOpenWriteId();
+
+    case ABORTED_BITS:
+      return getAbortedBits();
+
+    }
+    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 FULL_TABLE_NAME:
+      return isSetFullTableName();
+    case WRITE_ID_HIGH_WATER_MARK:
+      return isSetWriteIdHighWaterMark();
+    case INVALID_WRITE_IDS:
+      return isSetInvalidWriteIds();
+    case MIN_OPEN_WRITE_ID:
+      return isSetMinOpenWriteId();
+    case ABORTED_BITS:
+      return isSetAbortedBits();
+    }
+    throw new IllegalStateException();
+  }
+
+  @Override
+  public boolean equals(Object that) {
+    if (that == null)
+      return false;
+    if (that instanceof TableValidWriteIds)
+      return this.equals((TableValidWriteIds)that);
+    return false;
+  }
+
+  public boolean equals(TableValidWriteIds that) {
+    if (that == null)
+      return false;
+
+    boolean this_present_fullTableName = true && this.isSetFullTableName();
+    boolean that_present_fullTableName = true && that.isSetFullTableName();
+    if (this_present_fullTableName || that_present_fullTableName) {
+      if (!(this_present_fullTableName && that_present_fullTableName))
+        return false;
+      if (!this.fullTableName.equals(that.fullTableName))
+        return false;
+    }
+
+    boolean this_present_writeIdHighWaterMark = true;
+    boolean that_present_writeIdHighWaterMark = true;
+    if (this_present_writeIdHighWaterMark || 
that_present_writeIdHighWaterMark) {
+      if (!(this_present_writeIdHighWaterMark && 
that_present_writeIdHighWaterMark))
+        return false;
+      if (this.writeIdHighWaterMark != that.writeIdHighWaterMark)
+        return false;
+    }
+
+    boolean this_present_invalidWriteIds = true && this.isSetInvalidWriteIds();
+    boolean that_present_invalidWriteIds = true && that.isSetInvalidWriteIds();
+    if (this_present_invalidWriteIds || that_present_invalidWriteIds) {
+      if (!(this_present_invalidWriteIds && that_present_invalidWriteIds))
+        return false;
+      if (!this.invalidWriteIds.equals(that.invalidWriteIds))
+        return false;
+    }
+
+    boolean this_present_minOpenWriteId = true && this.isSetMinOpenWriteId();
+    boolean that_present_minOpenWriteId = true && that.isSetMinOpenWriteId();
+    if (this_present_minOpenWriteId || that_present_minOpenWriteId) {
+      if (!(this_present_minOpenWriteId && that_present_minOpenWriteId))
+        return false;
+      if (this.minOpenWriteId != that.minOpenWriteId)
+        return false;
+    }
+
+    boolean this_present_abortedBits = true && this.isSetAbortedBits();
+    boolean that_present_abortedBits = true && that.isSetAbortedBits();
+    if (this_present_abortedBits || that_present_abortedBits) {
+      if (!(this_present_abortedBits && that_present_abortedBits))
+        return false;
+      if (!this.abortedBits.equals(that.abortedBits))
+        return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    List<Object> list = new ArrayList<Object>();
+
+    boolean present_fullTableName = true && (isSetFullTableName());
+    list.add(present_fullTableName);
+    if (present_fullTableName)
+      list.add(fullTableName);
+
+    boolean present_writeIdHighWaterMark = true;
+    list.add(present_writeIdHighWaterMark);
+    if (present_writeIdHighWaterMark)
+      list.add(writeIdHighWaterMark);
+
+    boolean present_invalidWriteIds = true && (isSetInvalidWriteIds());
+    list.add(present_invalidWriteIds);
+    if (present_invalidWriteIds)
+      list.add(invalidWriteIds);
+
+    boolean present_minOpenWriteId = true && (isSetMinOpenWriteId());
+    list.add(present_minOpenWriteId);
+    if (present_minOpenWriteId)
+      list.add(minOpenWriteId);
+
+    boolean present_abortedBits = true && (isSetAbortedBits());
+    list.add(present_abortedBits);
+    if (present_abortedBits)
+      list.add(abortedBits);
+
+    return list.hashCode();
+  }
+
+  @Override
+  public int compareTo(TableValidWriteIds other) {
+    if (!getClass().equals(other.getClass())) {
+      return getClass().getName().compareTo(other.getClass().getName());
+    }
+
+    int lastComparison = 0;
+
+    lastComparison = 
Boolean.valueOf(isSetFullTableName()).compareTo(other.isSetFullTableName());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetFullTableName()) {
+      lastComparison = 
org.apache.thrift.TBaseHelper.compareTo(this.fullTableName, 
other.fullTableName);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = 
Boolean.valueOf(isSetWriteIdHighWaterMark()).compareTo(other.isSetWriteIdHighWaterMark());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetWriteIdHighWaterMark()) {
+      lastComparison = 
org.apache.thrift.TBaseHelper.compareTo(this.writeIdHighWaterMark, 
other.writeIdHighWaterMark);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = 
Boolean.valueOf(isSetInvalidWriteIds()).compareTo(other.isSetInvalidWriteIds());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetInvalidWriteIds()) {
+      lastComparison = 
org.apache.thrift.TBaseHelper.compareTo(this.invalidWriteIds, 
other.invalidWriteIds);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = 
Boolean.valueOf(isSetMinOpenWriteId()).compareTo(other.isSetMinOpenWriteId());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetMinOpenWriteId()) {
+      lastComparison = 
org.apache.thrift.TBaseHelper.compareTo(this.minOpenWriteId, 
other.minOpenWriteId);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
+    lastComparison = 
Boolean.valueOf(isSetAbortedBits()).compareTo(other.isSetAbortedBits());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetAbortedBits()) {
+      lastComparison = 
org.apache.thrift.TBaseHelper.compareTo(this.abortedBits, other.abortedBits);
+      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("TableValidWriteIds(");
+    boolean first = true;
+
+    sb.append("fullTableName:");
+    if (this.fullTableName == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.fullTableName);
+    }
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("writeIdHighWaterMark:");
+    sb.append(this.writeIdHighWaterMark);
+    first = false;
+    if (!first) sb.append(", ");
+    sb.append("invalidWriteIds:");
+    if (this.invalidWriteIds == null) {
+      sb.append("null");
+    } else {
+      sb.append(this.invalidWriteIds);
+    }
+    first = false;
+    if (isSetMinOpenWriteId()) {
+      if (!first) sb.append(", ");
+      sb.append("minOpenWriteId:");
+      sb.append(this.minOpenWriteId);
+      first = false;
+    }
+    if (!first) sb.append(", ");
+    sb.append("abortedBits:");
+    if (this.abortedBits == null) {
+      sb.append("null");
+    } else {
+      org.apache.thrift.TBaseHelper.toString(this.abortedBits, sb);
+    }
+    first = false;
+    sb.append(")");
+    return sb.toString();
+  }
+
+  public void validate() throws org.apache.thrift.TException {
+    // check for required fields
+    if (!isSetFullTableName()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 
'fullTableName' is unset! Struct:" + toString());
+    }
+
+    if (!isSetWriteIdHighWaterMark()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 
'writeIdHighWaterMark' is unset! Struct:" + toString());
+    }
+
+    if (!isSetInvalidWriteIds()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 
'invalidWriteIds' is unset! Struct:" + toString());
+    }
+
+    if (!isSetAbortedBits()) {
+      throw new org.apache.thrift.protocol.TProtocolException("Required field 
'abortedBits' 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 TableValidWriteIdsStandardSchemeFactory implements 
SchemeFactory {
+    public TableValidWriteIdsStandardScheme getScheme() {
+      return new TableValidWriteIdsStandardScheme();
+    }
+  }
+
+  private static class TableValidWriteIdsStandardScheme extends 
StandardScheme<TableValidWriteIds> {
+
+    public void read(org.apache.thrift.protocol.TProtocol iprot, 
TableValidWriteIds 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: // FULL_TABLE_NAME
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.fullTableName = iprot.readString();
+              struct.setFullTableNameIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, 
schemeField.type);
+            }
+            break;
+          case 2: // WRITE_ID_HIGH_WATER_MARK
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.writeIdHighWaterMark = iprot.readI64();
+              struct.setWriteIdHighWaterMarkIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, 
schemeField.type);
+            }
+            break;
+          case 3: // INVALID_WRITE_IDS
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list564 = 
iprot.readListBegin();
+                struct.invalidWriteIds = new ArrayList<Long>(_list564.size);
+                long _elem565;
+                for (int _i566 = 0; _i566 < _list564.size; ++_i566)
+                {
+                  _elem565 = iprot.readI64();
+                  struct.invalidWriteIds.add(_elem565);
+                }
+                iprot.readListEnd();
+              }
+              struct.setInvalidWriteIdsIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, 
schemeField.type);
+            }
+            break;
+          case 4: // MIN_OPEN_WRITE_ID
+            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
+              struct.minOpenWriteId = iprot.readI64();
+              struct.setMinOpenWriteIdIsSet(true);
+            } else { 
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, 
schemeField.type);
+            }
+            break;
+          case 5: // ABORTED_BITS
+            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
+              struct.abortedBits = iprot.readBinary();
+              struct.setAbortedBitsIsSet(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, 
TableValidWriteIds struct) throws org.apache.thrift.TException {
+      struct.validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (struct.fullTableName != null) {
+        oprot.writeFieldBegin(FULL_TABLE_NAME_FIELD_DESC);
+        oprot.writeString(struct.fullTableName);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldBegin(WRITE_ID_HIGH_WATER_MARK_FIELD_DESC);
+      oprot.writeI64(struct.writeIdHighWaterMark);
+      oprot.writeFieldEnd();
+      if (struct.invalidWriteIds != null) {
+        oprot.writeFieldBegin(INVALID_WRITE_IDS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, 
struct.invalidWriteIds.size()));
+          for (long _iter567 : struct.invalidWriteIds)
+          {
+            oprot.writeI64(_iter567);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      if (struct.isSetMinOpenWriteId()) {
+        oprot.writeFieldBegin(MIN_OPEN_WRITE_ID_FIELD_DESC);
+        oprot.writeI64(struct.minOpenWriteId);
+        oprot.writeFieldEnd();
+      }
+      if (struct.abortedBits != null) {
+        oprot.writeFieldBegin(ABORTED_BITS_FIELD_DESC);
+        oprot.writeBinary(struct.abortedBits);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+  }
+
+  private static class TableValidWriteIdsTupleSchemeFactory implements 
SchemeFactory {
+    public TableValidWriteIdsTupleScheme getScheme() {
+      return new TableValidWriteIdsTupleScheme();
+    }
+  }
+
+  private static class TableValidWriteIdsTupleScheme extends 
TupleScheme<TableValidWriteIds> {
+
+    @Override
+    public void write(org.apache.thrift.protocol.TProtocol prot, 
TableValidWriteIds struct) throws org.apache.thrift.TException {
+      TTupleProtocol oprot = (TTupleProtocol) prot;
+      oprot.writeString(struct.fullTableName);
+      oprot.writeI64(struct.writeIdHighWaterMark);
+      {
+        oprot.writeI32(struct.invalidWriteIds.size());
+        for (long _iter568 : struct.invalidWriteIds)
+        {
+          oprot.writeI64(_iter568);
+        }
+      }
+      oprot.writeBinary(struct.abortedBits);
+      BitSet optionals = new BitSet();
+      if (struct.isSetMinOpenWriteId()) {
+        optionals.set(0);
+      }
+      oprot.writeBitSet(optionals, 1);
+      if (struct.isSetMinOpenWriteId()) {
+        oprot.writeI64(struct.minOpenWriteId);
+      }
+    }
+
+    @Override
+    public void read(org.apache.thrift.protocol.TProtocol prot, 
TableValidWriteIds struct) throws org.apache.thrift.TException {
+      TTupleProtocol iprot = (TTupleProtocol) prot;
+      struct.fullTableName = iprot.readString();
+      struct.setFullTableNameIsSet(true);
+      struct.writeIdHighWaterMark = iprot.readI64();
+      struct.setWriteIdHighWaterMarkIsSet(true);
+      {
+        org.apache.thrift.protocol.TList _list569 = new 
org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, 
iprot.readI32());
+        struct.invalidWriteIds = new ArrayList<Long>(_list569.size);
+        long _elem570;
+        for (int _i571 = 0; _i571 < _list569.size; ++_i571)
+        {
+          _elem570 = iprot.readI64();
+          struct.invalidWriteIds.add(_elem570);
+        }
+      }
+      struct.setInvalidWriteIdsIsSet(true);
+      struct.abortedBits = iprot.readBinary();
+      struct.setAbortedBitsIsSet(true);
+      BitSet incoming = iprot.readBitSet(1);
+      if (incoming.get(0)) {
+        struct.minOpenWriteId = iprot.readI64();
+        struct.setMinOpenWriteIdIsSet(true);
+      }
+    }
+  }
+
+}
+

Reply via email to