http://git-wip-us.apache.org/repos/asf/hive/blob/0a328f03/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git 
a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp 
b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index 27f8c0f..aadf8f1 100644
--- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -4940,7 +4940,7 @@ void Table::__set_rewriteEnabled(const bool val) {
 __isset.rewriteEnabled = true;
 }
 
-void Table::__set_creationMetadata(const std::map<std::string, BasicTxnInfo> & 
val) {
+void Table::__set_creationMetadata(const CreationMetadata& val) {
   this->creationMetadata = val;
 __isset.creationMetadata = true;
 }
@@ -5114,23 +5114,8 @@ uint32_t 
Table::read(::apache::thrift::protocol::TProtocol* iprot) {
         }
         break;
       case 16:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            this->creationMetadata.clear();
-            uint32_t _size223;
-            ::apache::thrift::protocol::TType _ktype224;
-            ::apache::thrift::protocol::TType _vtype225;
-            xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223);
-            uint32_t _i227;
-            for (_i227 = 0; _i227 < _size223; ++_i227)
-            {
-              std::string _key228;
-              xfer += iprot->readString(_key228);
-              BasicTxnInfo& _val229 = this->creationMetadata[_key228];
-              xfer += _val229.read(iprot);
-            }
-            xfer += iprot->readMapEnd();
-          }
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->creationMetadata.read(iprot);
           this->__isset.creationMetadata = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5184,10 +5169,10 @@ uint32_t 
Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("partitionKeys", 
::apache::thrift::protocol::T_LIST, 8);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->partitionKeys.size()));
-    std::vector<FieldSchema> ::const_iterator _iter230;
-    for (_iter230 = this->partitionKeys.begin(); _iter230 != 
this->partitionKeys.end(); ++_iter230)
+    std::vector<FieldSchema> ::const_iterator _iter223;
+    for (_iter223 = this->partitionKeys.begin(); _iter223 != 
this->partitionKeys.end(); ++_iter223)
     {
-      xfer += (*_iter230).write(oprot);
+      xfer += (*_iter223).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -5196,11 +5181,11 @@ uint32_t 
Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("parameters", 
::apache::thrift::protocol::T_MAP, 9);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->parameters.size()));
-    std::map<std::string, std::string> ::const_iterator _iter231;
-    for (_iter231 = this->parameters.begin(); _iter231 != 
this->parameters.end(); ++_iter231)
+    std::map<std::string, std::string> ::const_iterator _iter224;
+    for (_iter224 = this->parameters.begin(); _iter224 != 
this->parameters.end(); ++_iter224)
     {
-      xfer += oprot->writeString(_iter231->first);
-      xfer += oprot->writeString(_iter231->second);
+      xfer += oprot->writeString(_iter224->first);
+      xfer += oprot->writeString(_iter224->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -5234,17 +5219,8 @@ uint32_t 
Table::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldEnd();
   }
   if (this->__isset.creationMetadata) {
-    xfer += oprot->writeFieldBegin("creationMetadata", 
::apache::thrift::protocol::T_MAP, 16);
-    {
-      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->creationMetadata.size()));
-      std::map<std::string, BasicTxnInfo> ::const_iterator _iter232;
-      for (_iter232 = this->creationMetadata.begin(); _iter232 != 
this->creationMetadata.end(); ++_iter232)
-      {
-        xfer += oprot->writeString(_iter232->first);
-        xfer += _iter232->second.write(oprot);
-      }
-      xfer += oprot->writeMapEnd();
-    }
+    xfer += oprot->writeFieldBegin("creationMetadata", 
::apache::thrift::protocol::T_STRUCT, 16);
+    xfer += this->creationMetadata.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -5273,43 +5249,43 @@ void swap(Table &a, Table &b) {
   swap(a.__isset, b.__isset);
 }
 
-Table::Table(const Table& other233) {
-  tableName = other233.tableName;
-  dbName = other233.dbName;
-  owner = other233.owner;
-  createTime = other233.createTime;
-  lastAccessTime = other233.lastAccessTime;
-  retention = other233.retention;
-  sd = other233.sd;
-  partitionKeys = other233.partitionKeys;
-  parameters = other233.parameters;
-  viewOriginalText = other233.viewOriginalText;
-  viewExpandedText = other233.viewExpandedText;
-  tableType = other233.tableType;
-  privileges = other233.privileges;
-  temporary = other233.temporary;
-  rewriteEnabled = other233.rewriteEnabled;
-  creationMetadata = other233.creationMetadata;
-  __isset = other233.__isset;
-}
-Table& Table::operator=(const Table& other234) {
-  tableName = other234.tableName;
-  dbName = other234.dbName;
-  owner = other234.owner;
-  createTime = other234.createTime;
-  lastAccessTime = other234.lastAccessTime;
-  retention = other234.retention;
-  sd = other234.sd;
-  partitionKeys = other234.partitionKeys;
-  parameters = other234.parameters;
-  viewOriginalText = other234.viewOriginalText;
-  viewExpandedText = other234.viewExpandedText;
-  tableType = other234.tableType;
-  privileges = other234.privileges;
-  temporary = other234.temporary;
-  rewriteEnabled = other234.rewriteEnabled;
-  creationMetadata = other234.creationMetadata;
-  __isset = other234.__isset;
+Table::Table(const Table& other225) {
+  tableName = other225.tableName;
+  dbName = other225.dbName;
+  owner = other225.owner;
+  createTime = other225.createTime;
+  lastAccessTime = other225.lastAccessTime;
+  retention = other225.retention;
+  sd = other225.sd;
+  partitionKeys = other225.partitionKeys;
+  parameters = other225.parameters;
+  viewOriginalText = other225.viewOriginalText;
+  viewExpandedText = other225.viewExpandedText;
+  tableType = other225.tableType;
+  privileges = other225.privileges;
+  temporary = other225.temporary;
+  rewriteEnabled = other225.rewriteEnabled;
+  creationMetadata = other225.creationMetadata;
+  __isset = other225.__isset;
+}
+Table& Table::operator=(const Table& other226) {
+  tableName = other226.tableName;
+  dbName = other226.dbName;
+  owner = other226.owner;
+  createTime = other226.createTime;
+  lastAccessTime = other226.lastAccessTime;
+  retention = other226.retention;
+  sd = other226.sd;
+  partitionKeys = other226.partitionKeys;
+  parameters = other226.parameters;
+  viewOriginalText = other226.viewOriginalText;
+  viewExpandedText = other226.viewExpandedText;
+  tableType = other226.tableType;
+  privileges = other226.privileges;
+  temporary = other226.temporary;
+  rewriteEnabled = other226.rewriteEnabled;
+  creationMetadata = other226.creationMetadata;
+  __isset = other226.__isset;
   return *this;
 }
 void Table::printTo(std::ostream& out) const {
@@ -5397,14 +5373,14 @@ uint32_t 
Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->values.clear();
-            uint32_t _size235;
-            ::apache::thrift::protocol::TType _etype238;
-            xfer += iprot->readListBegin(_etype238, _size235);
-            this->values.resize(_size235);
-            uint32_t _i239;
-            for (_i239 = 0; _i239 < _size235; ++_i239)
+            uint32_t _size227;
+            ::apache::thrift::protocol::TType _etype230;
+            xfer += iprot->readListBegin(_etype230, _size227);
+            this->values.resize(_size227);
+            uint32_t _i231;
+            for (_i231 = 0; _i231 < _size227; ++_i231)
             {
-              xfer += iprot->readString(this->values[_i239]);
+              xfer += iprot->readString(this->values[_i231]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5457,17 +5433,17 @@ uint32_t 
Partition::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->parameters.clear();
-            uint32_t _size240;
-            ::apache::thrift::protocol::TType _ktype241;
-            ::apache::thrift::protocol::TType _vtype242;
-            xfer += iprot->readMapBegin(_ktype241, _vtype242, _size240);
-            uint32_t _i244;
-            for (_i244 = 0; _i244 < _size240; ++_i244)
+            uint32_t _size232;
+            ::apache::thrift::protocol::TType _ktype233;
+            ::apache::thrift::protocol::TType _vtype234;
+            xfer += iprot->readMapBegin(_ktype233, _vtype234, _size232);
+            uint32_t _i236;
+            for (_i236 = 0; _i236 < _size232; ++_i236)
             {
-              std::string _key245;
-              xfer += iprot->readString(_key245);
-              std::string& _val246 = this->parameters[_key245];
-              xfer += iprot->readString(_val246);
+              std::string _key237;
+              xfer += iprot->readString(_key237);
+              std::string& _val238 = this->parameters[_key237];
+              xfer += iprot->readString(_val238);
             }
             xfer += iprot->readMapEnd();
           }
@@ -5504,10 +5480,10 @@ uint32_t 
Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 
1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->values.size()));
-    std::vector<std::string> ::const_iterator _iter247;
-    for (_iter247 = this->values.begin(); _iter247 != this->values.end(); 
++_iter247)
+    std::vector<std::string> ::const_iterator _iter239;
+    for (_iter239 = this->values.begin(); _iter239 != this->values.end(); 
++_iter239)
     {
-      xfer += oprot->writeString((*_iter247));
+      xfer += oprot->writeString((*_iter239));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5536,11 +5512,11 @@ uint32_t 
Partition::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("parameters", 
::apache::thrift::protocol::T_MAP, 7);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->parameters.size()));
-    std::map<std::string, std::string> ::const_iterator _iter248;
-    for (_iter248 = this->parameters.begin(); _iter248 != 
this->parameters.end(); ++_iter248)
+    std::map<std::string, std::string> ::const_iterator _iter240;
+    for (_iter240 = this->parameters.begin(); _iter240 != 
this->parameters.end(); ++_iter240)
     {
-      xfer += oprot->writeString(_iter248->first);
-      xfer += oprot->writeString(_iter248->second);
+      xfer += oprot->writeString(_iter240->first);
+      xfer += oprot->writeString(_iter240->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -5569,27 +5545,27 @@ void swap(Partition &a, Partition &b) {
   swap(a.__isset, b.__isset);
 }
 
-Partition::Partition(const Partition& other249) {
-  values = other249.values;
-  dbName = other249.dbName;
-  tableName = other249.tableName;
-  createTime = other249.createTime;
-  lastAccessTime = other249.lastAccessTime;
-  sd = other249.sd;
-  parameters = other249.parameters;
-  privileges = other249.privileges;
-  __isset = other249.__isset;
-}
-Partition& Partition::operator=(const Partition& other250) {
-  values = other250.values;
-  dbName = other250.dbName;
-  tableName = other250.tableName;
-  createTime = other250.createTime;
-  lastAccessTime = other250.lastAccessTime;
-  sd = other250.sd;
-  parameters = other250.parameters;
-  privileges = other250.privileges;
-  __isset = other250.__isset;
+Partition::Partition(const Partition& other241) {
+  values = other241.values;
+  dbName = other241.dbName;
+  tableName = other241.tableName;
+  createTime = other241.createTime;
+  lastAccessTime = other241.lastAccessTime;
+  sd = other241.sd;
+  parameters = other241.parameters;
+  privileges = other241.privileges;
+  __isset = other241.__isset;
+}
+Partition& Partition::operator=(const Partition& other242) {
+  values = other242.values;
+  dbName = other242.dbName;
+  tableName = other242.tableName;
+  createTime = other242.createTime;
+  lastAccessTime = other242.lastAccessTime;
+  sd = other242.sd;
+  parameters = other242.parameters;
+  privileges = other242.privileges;
+  __isset = other242.__isset;
   return *this;
 }
 void Partition::printTo(std::ostream& out) const {
@@ -5661,14 +5637,14 @@ uint32_t 
PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->values.clear();
-            uint32_t _size251;
-            ::apache::thrift::protocol::TType _etype254;
-            xfer += iprot->readListBegin(_etype254, _size251);
-            this->values.resize(_size251);
-            uint32_t _i255;
-            for (_i255 = 0; _i255 < _size251; ++_i255)
+            uint32_t _size243;
+            ::apache::thrift::protocol::TType _etype246;
+            xfer += iprot->readListBegin(_etype246, _size243);
+            this->values.resize(_size243);
+            uint32_t _i247;
+            for (_i247 = 0; _i247 < _size243; ++_i247)
             {
-              xfer += iprot->readString(this->values[_i255]);
+              xfer += iprot->readString(this->values[_i247]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5705,17 +5681,17 @@ uint32_t 
PartitionWithoutSD::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->parameters.clear();
-            uint32_t _size256;
-            ::apache::thrift::protocol::TType _ktype257;
-            ::apache::thrift::protocol::TType _vtype258;
-            xfer += iprot->readMapBegin(_ktype257, _vtype258, _size256);
-            uint32_t _i260;
-            for (_i260 = 0; _i260 < _size256; ++_i260)
+            uint32_t _size248;
+            ::apache::thrift::protocol::TType _ktype249;
+            ::apache::thrift::protocol::TType _vtype250;
+            xfer += iprot->readMapBegin(_ktype249, _vtype250, _size248);
+            uint32_t _i252;
+            for (_i252 = 0; _i252 < _size248; ++_i252)
             {
-              std::string _key261;
-              xfer += iprot->readString(_key261);
-              std::string& _val262 = this->parameters[_key261];
-              xfer += iprot->readString(_val262);
+              std::string _key253;
+              xfer += iprot->readString(_key253);
+              std::string& _val254 = this->parameters[_key253];
+              xfer += iprot->readString(_val254);
             }
             xfer += iprot->readMapEnd();
           }
@@ -5752,10 +5728,10 @@ uint32_t 
PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 
1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->values.size()));
-    std::vector<std::string> ::const_iterator _iter263;
-    for (_iter263 = this->values.begin(); _iter263 != this->values.end(); 
++_iter263)
+    std::vector<std::string> ::const_iterator _iter255;
+    for (_iter255 = this->values.begin(); _iter255 != this->values.end(); 
++_iter255)
     {
-      xfer += oprot->writeString((*_iter263));
+      xfer += oprot->writeString((*_iter255));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5776,11 +5752,11 @@ uint32_t 
PartitionWithoutSD::write(::apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("parameters", 
::apache::thrift::protocol::T_MAP, 5);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->parameters.size()));
-    std::map<std::string, std::string> ::const_iterator _iter264;
-    for (_iter264 = this->parameters.begin(); _iter264 != 
this->parameters.end(); ++_iter264)
+    std::map<std::string, std::string> ::const_iterator _iter256;
+    for (_iter256 = this->parameters.begin(); _iter256 != 
this->parameters.end(); ++_iter256)
     {
-      xfer += oprot->writeString(_iter264->first);
-      xfer += oprot->writeString(_iter264->second);
+      xfer += oprot->writeString(_iter256->first);
+      xfer += oprot->writeString(_iter256->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -5807,23 +5783,23 @@ void swap(PartitionWithoutSD &a, PartitionWithoutSD &b) 
{
   swap(a.__isset, b.__isset);
 }
 
-PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other265) {
-  values = other265.values;
-  createTime = other265.createTime;
-  lastAccessTime = other265.lastAccessTime;
-  relativePath = other265.relativePath;
-  parameters = other265.parameters;
-  privileges = other265.privileges;
-  __isset = other265.__isset;
-}
-PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& 
other266) {
-  values = other266.values;
-  createTime = other266.createTime;
-  lastAccessTime = other266.lastAccessTime;
-  relativePath = other266.relativePath;
-  parameters = other266.parameters;
-  privileges = other266.privileges;
-  __isset = other266.__isset;
+PartitionWithoutSD::PartitionWithoutSD(const PartitionWithoutSD& other257) {
+  values = other257.values;
+  createTime = other257.createTime;
+  lastAccessTime = other257.lastAccessTime;
+  relativePath = other257.relativePath;
+  parameters = other257.parameters;
+  privileges = other257.privileges;
+  __isset = other257.__isset;
+}
+PartitionWithoutSD& PartitionWithoutSD::operator=(const PartitionWithoutSD& 
other258) {
+  values = other258.values;
+  createTime = other258.createTime;
+  lastAccessTime = other258.lastAccessTime;
+  relativePath = other258.relativePath;
+  parameters = other258.parameters;
+  privileges = other258.privileges;
+  __isset = other258.__isset;
   return *this;
 }
 void PartitionWithoutSD::printTo(std::ostream& out) const {
@@ -5876,14 +5852,14 @@ uint32_t 
PartitionSpecWithSharedSD::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->partitions.clear();
-            uint32_t _size267;
-            ::apache::thrift::protocol::TType _etype270;
-            xfer += iprot->readListBegin(_etype270, _size267);
-            this->partitions.resize(_size267);
-            uint32_t _i271;
-            for (_i271 = 0; _i271 < _size267; ++_i271)
+            uint32_t _size259;
+            ::apache::thrift::protocol::TType _etype262;
+            xfer += iprot->readListBegin(_etype262, _size259);
+            this->partitions.resize(_size259);
+            uint32_t _i263;
+            for (_i263 = 0; _i263 < _size259; ++_i263)
             {
-              xfer += this->partitions[_i271].read(iprot);
+              xfer += this->partitions[_i263].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5920,10 +5896,10 @@ uint32_t 
PartitionSpecWithSharedSD::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("partitions", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->partitions.size()));
-    std::vector<PartitionWithoutSD> ::const_iterator _iter272;
-    for (_iter272 = this->partitions.begin(); _iter272 != 
this->partitions.end(); ++_iter272)
+    std::vector<PartitionWithoutSD> ::const_iterator _iter264;
+    for (_iter264 = this->partitions.begin(); _iter264 != 
this->partitions.end(); ++_iter264)
     {
-      xfer += (*_iter272).write(oprot);
+      xfer += (*_iter264).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -5945,15 +5921,15 @@ void swap(PartitionSpecWithSharedSD &a, 
PartitionSpecWithSharedSD &b) {
   swap(a.__isset, b.__isset);
 }
 
-PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const 
PartitionSpecWithSharedSD& other273) {
-  partitions = other273.partitions;
-  sd = other273.sd;
-  __isset = other273.__isset;
+PartitionSpecWithSharedSD::PartitionSpecWithSharedSD(const 
PartitionSpecWithSharedSD& other265) {
+  partitions = other265.partitions;
+  sd = other265.sd;
+  __isset = other265.__isset;
 }
-PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const 
PartitionSpecWithSharedSD& other274) {
-  partitions = other274.partitions;
-  sd = other274.sd;
-  __isset = other274.__isset;
+PartitionSpecWithSharedSD& PartitionSpecWithSharedSD::operator=(const 
PartitionSpecWithSharedSD& other266) {
+  partitions = other266.partitions;
+  sd = other266.sd;
+  __isset = other266.__isset;
   return *this;
 }
 void PartitionSpecWithSharedSD::printTo(std::ostream& out) const {
@@ -5998,14 +5974,14 @@ uint32_t 
PartitionListComposingSpec::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->partitions.clear();
-            uint32_t _size275;
-            ::apache::thrift::protocol::TType _etype278;
-            xfer += iprot->readListBegin(_etype278, _size275);
-            this->partitions.resize(_size275);
-            uint32_t _i279;
-            for (_i279 = 0; _i279 < _size275; ++_i279)
+            uint32_t _size267;
+            ::apache::thrift::protocol::TType _etype270;
+            xfer += iprot->readListBegin(_etype270, _size267);
+            this->partitions.resize(_size267);
+            uint32_t _i271;
+            for (_i271 = 0; _i271 < _size267; ++_i271)
             {
-              xfer += this->partitions[_i279].read(iprot);
+              xfer += this->partitions[_i271].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -6034,10 +6010,10 @@ uint32_t 
PartitionListComposingSpec::write(::apache::thrift::protocol::TProtocol
   xfer += oprot->writeFieldBegin("partitions", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->partitions.size()));
-    std::vector<Partition> ::const_iterator _iter280;
-    for (_iter280 = this->partitions.begin(); _iter280 != 
this->partitions.end(); ++_iter280)
+    std::vector<Partition> ::const_iterator _iter272;
+    for (_iter272 = this->partitions.begin(); _iter272 != 
this->partitions.end(); ++_iter272)
     {
-      xfer += (*_iter280).write(oprot);
+      xfer += (*_iter272).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -6054,13 +6030,13 @@ void swap(PartitionListComposingSpec &a, 
PartitionListComposingSpec &b) {
   swap(a.__isset, b.__isset);
 }
 
-PartitionListComposingSpec::PartitionListComposingSpec(const 
PartitionListComposingSpec& other281) {
-  partitions = other281.partitions;
-  __isset = other281.__isset;
+PartitionListComposingSpec::PartitionListComposingSpec(const 
PartitionListComposingSpec& other273) {
+  partitions = other273.partitions;
+  __isset = other273.__isset;
 }
-PartitionListComposingSpec& PartitionListComposingSpec::operator=(const 
PartitionListComposingSpec& other282) {
-  partitions = other282.partitions;
-  __isset = other282.__isset;
+PartitionListComposingSpec& PartitionListComposingSpec::operator=(const 
PartitionListComposingSpec& other274) {
+  partitions = other274.partitions;
+  __isset = other274.__isset;
   return *this;
 }
 void PartitionListComposingSpec::printTo(std::ostream& out) const {
@@ -6212,21 +6188,21 @@ void swap(PartitionSpec &a, PartitionSpec &b) {
   swap(a.__isset, b.__isset);
 }
 
-PartitionSpec::PartitionSpec(const PartitionSpec& other283) {
-  dbName = other283.dbName;
-  tableName = other283.tableName;
-  rootPath = other283.rootPath;
-  sharedSDPartitionSpec = other283.sharedSDPartitionSpec;
-  partitionList = other283.partitionList;
-  __isset = other283.__isset;
-}
-PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other284) {
-  dbName = other284.dbName;
-  tableName = other284.tableName;
-  rootPath = other284.rootPath;
-  sharedSDPartitionSpec = other284.sharedSDPartitionSpec;
-  partitionList = other284.partitionList;
-  __isset = other284.__isset;
+PartitionSpec::PartitionSpec(const PartitionSpec& other275) {
+  dbName = other275.dbName;
+  tableName = other275.tableName;
+  rootPath = other275.rootPath;
+  sharedSDPartitionSpec = other275.sharedSDPartitionSpec;
+  partitionList = other275.partitionList;
+  __isset = other275.__isset;
+}
+PartitionSpec& PartitionSpec::operator=(const PartitionSpec& other276) {
+  dbName = other276.dbName;
+  tableName = other276.tableName;
+  rootPath = other276.rootPath;
+  sharedSDPartitionSpec = other276.sharedSDPartitionSpec;
+  partitionList = other276.partitionList;
+  __isset = other276.__isset;
   return *this;
 }
 void PartitionSpec::printTo(std::ostream& out) const {
@@ -6374,17 +6350,17 @@ uint32_t 
Index::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->parameters.clear();
-            uint32_t _size285;
-            ::apache::thrift::protocol::TType _ktype286;
-            ::apache::thrift::protocol::TType _vtype287;
-            xfer += iprot->readMapBegin(_ktype286, _vtype287, _size285);
-            uint32_t _i289;
-            for (_i289 = 0; _i289 < _size285; ++_i289)
+            uint32_t _size277;
+            ::apache::thrift::protocol::TType _ktype278;
+            ::apache::thrift::protocol::TType _vtype279;
+            xfer += iprot->readMapBegin(_ktype278, _vtype279, _size277);
+            uint32_t _i281;
+            for (_i281 = 0; _i281 < _size277; ++_i281)
             {
-              std::string _key290;
-              xfer += iprot->readString(_key290);
-              std::string& _val291 = this->parameters[_key290];
-              xfer += iprot->readString(_val291);
+              std::string _key282;
+              xfer += iprot->readString(_key282);
+              std::string& _val283 = this->parameters[_key282];
+              xfer += iprot->readString(_val283);
             }
             xfer += iprot->readMapEnd();
           }
@@ -6453,11 +6429,11 @@ uint32_t 
Index::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("parameters", 
::apache::thrift::protocol::T_MAP, 9);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->parameters.size()));
-    std::map<std::string, std::string> ::const_iterator _iter292;
-    for (_iter292 = this->parameters.begin(); _iter292 != 
this->parameters.end(); ++_iter292)
+    std::map<std::string, std::string> ::const_iterator _iter284;
+    for (_iter284 = this->parameters.begin(); _iter284 != 
this->parameters.end(); ++_iter284)
     {
-      xfer += oprot->writeString(_iter292->first);
-      xfer += oprot->writeString(_iter292->second);
+      xfer += oprot->writeString(_iter284->first);
+      xfer += oprot->writeString(_iter284->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -6487,31 +6463,31 @@ void swap(Index &a, Index &b) {
   swap(a.__isset, b.__isset);
 }
 
-Index::Index(const Index& other293) {
-  indexName = other293.indexName;
-  indexHandlerClass = other293.indexHandlerClass;
-  dbName = other293.dbName;
-  origTableName = other293.origTableName;
-  createTime = other293.createTime;
-  lastAccessTime = other293.lastAccessTime;
-  indexTableName = other293.indexTableName;
-  sd = other293.sd;
-  parameters = other293.parameters;
-  deferredRebuild = other293.deferredRebuild;
-  __isset = other293.__isset;
-}
-Index& Index::operator=(const Index& other294) {
-  indexName = other294.indexName;
-  indexHandlerClass = other294.indexHandlerClass;
-  dbName = other294.dbName;
-  origTableName = other294.origTableName;
-  createTime = other294.createTime;
-  lastAccessTime = other294.lastAccessTime;
-  indexTableName = other294.indexTableName;
-  sd = other294.sd;
-  parameters = other294.parameters;
-  deferredRebuild = other294.deferredRebuild;
-  __isset = other294.__isset;
+Index::Index(const Index& other285) {
+  indexName = other285.indexName;
+  indexHandlerClass = other285.indexHandlerClass;
+  dbName = other285.dbName;
+  origTableName = other285.origTableName;
+  createTime = other285.createTime;
+  lastAccessTime = other285.lastAccessTime;
+  indexTableName = other285.indexTableName;
+  sd = other285.sd;
+  parameters = other285.parameters;
+  deferredRebuild = other285.deferredRebuild;
+  __isset = other285.__isset;
+}
+Index& Index::operator=(const Index& other286) {
+  indexName = other286.indexName;
+  indexHandlerClass = other286.indexHandlerClass;
+  dbName = other286.dbName;
+  origTableName = other286.origTableName;
+  createTime = other286.createTime;
+  lastAccessTime = other286.lastAccessTime;
+  indexTableName = other286.indexTableName;
+  sd = other286.sd;
+  parameters = other286.parameters;
+  deferredRebuild = other286.deferredRebuild;
+  __isset = other286.__isset;
   return *this;
 }
 void Index::printTo(std::ostream& out) const {
@@ -6662,19 +6638,19 @@ void swap(BooleanColumnStatsData &a, 
BooleanColumnStatsData &b) {
   swap(a.__isset, b.__isset);
 }
 
-BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& 
other295) {
-  numTrues = other295.numTrues;
-  numFalses = other295.numFalses;
-  numNulls = other295.numNulls;
-  bitVectors = other295.bitVectors;
-  __isset = other295.__isset;
+BooleanColumnStatsData::BooleanColumnStatsData(const BooleanColumnStatsData& 
other287) {
+  numTrues = other287.numTrues;
+  numFalses = other287.numFalses;
+  numNulls = other287.numNulls;
+  bitVectors = other287.bitVectors;
+  __isset = other287.__isset;
 }
-BooleanColumnStatsData& BooleanColumnStatsData::operator=(const 
BooleanColumnStatsData& other296) {
-  numTrues = other296.numTrues;
-  numFalses = other296.numFalses;
-  numNulls = other296.numNulls;
-  bitVectors = other296.bitVectors;
-  __isset = other296.__isset;
+BooleanColumnStatsData& BooleanColumnStatsData::operator=(const 
BooleanColumnStatsData& other288) {
+  numTrues = other288.numTrues;
+  numFalses = other288.numFalses;
+  numNulls = other288.numNulls;
+  bitVectors = other288.bitVectors;
+  __isset = other288.__isset;
   return *this;
 }
 void BooleanColumnStatsData::printTo(std::ostream& out) const {
@@ -6837,21 +6813,21 @@ void swap(DoubleColumnStatsData &a, 
DoubleColumnStatsData &b) {
   swap(a.__isset, b.__isset);
 }
 
-DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& 
other297) {
-  lowValue = other297.lowValue;
-  highValue = other297.highValue;
-  numNulls = other297.numNulls;
-  numDVs = other297.numDVs;
-  bitVectors = other297.bitVectors;
-  __isset = other297.__isset;
-}
-DoubleColumnStatsData& DoubleColumnStatsData::operator=(const 
DoubleColumnStatsData& other298) {
-  lowValue = other298.lowValue;
-  highValue = other298.highValue;
-  numNulls = other298.numNulls;
-  numDVs = other298.numDVs;
-  bitVectors = other298.bitVectors;
-  __isset = other298.__isset;
+DoubleColumnStatsData::DoubleColumnStatsData(const DoubleColumnStatsData& 
other289) {
+  lowValue = other289.lowValue;
+  highValue = other289.highValue;
+  numNulls = other289.numNulls;
+  numDVs = other289.numDVs;
+  bitVectors = other289.bitVectors;
+  __isset = other289.__isset;
+}
+DoubleColumnStatsData& DoubleColumnStatsData::operator=(const 
DoubleColumnStatsData& other290) {
+  lowValue = other290.lowValue;
+  highValue = other290.highValue;
+  numNulls = other290.numNulls;
+  numDVs = other290.numDVs;
+  bitVectors = other290.bitVectors;
+  __isset = other290.__isset;
   return *this;
 }
 void DoubleColumnStatsData::printTo(std::ostream& out) const {
@@ -7015,21 +6991,21 @@ void swap(LongColumnStatsData &a, LongColumnStatsData 
&b) {
   swap(a.__isset, b.__isset);
 }
 
-LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other299) {
-  lowValue = other299.lowValue;
-  highValue = other299.highValue;
-  numNulls = other299.numNulls;
-  numDVs = other299.numDVs;
-  bitVectors = other299.bitVectors;
-  __isset = other299.__isset;
-}
-LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& 
other300) {
-  lowValue = other300.lowValue;
-  highValue = other300.highValue;
-  numNulls = other300.numNulls;
-  numDVs = other300.numDVs;
-  bitVectors = other300.bitVectors;
-  __isset = other300.__isset;
+LongColumnStatsData::LongColumnStatsData(const LongColumnStatsData& other291) {
+  lowValue = other291.lowValue;
+  highValue = other291.highValue;
+  numNulls = other291.numNulls;
+  numDVs = other291.numDVs;
+  bitVectors = other291.bitVectors;
+  __isset = other291.__isset;
+}
+LongColumnStatsData& LongColumnStatsData::operator=(const LongColumnStatsData& 
other292) {
+  lowValue = other292.lowValue;
+  highValue = other292.highValue;
+  numNulls = other292.numNulls;
+  numDVs = other292.numDVs;
+  bitVectors = other292.bitVectors;
+  __isset = other292.__isset;
   return *this;
 }
 void LongColumnStatsData::printTo(std::ostream& out) const {
@@ -7195,21 +7171,21 @@ void swap(StringColumnStatsData &a, 
StringColumnStatsData &b) {
   swap(a.__isset, b.__isset);
 }
 
-StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& 
other301) {
-  maxColLen = other301.maxColLen;
-  avgColLen = other301.avgColLen;
-  numNulls = other301.numNulls;
-  numDVs = other301.numDVs;
-  bitVectors = other301.bitVectors;
-  __isset = other301.__isset;
-}
-StringColumnStatsData& StringColumnStatsData::operator=(const 
StringColumnStatsData& other302) {
-  maxColLen = other302.maxColLen;
-  avgColLen = other302.avgColLen;
-  numNulls = other302.numNulls;
-  numDVs = other302.numDVs;
-  bitVectors = other302.bitVectors;
-  __isset = other302.__isset;
+StringColumnStatsData::StringColumnStatsData(const StringColumnStatsData& 
other293) {
+  maxColLen = other293.maxColLen;
+  avgColLen = other293.avgColLen;
+  numNulls = other293.numNulls;
+  numDVs = other293.numDVs;
+  bitVectors = other293.bitVectors;
+  __isset = other293.__isset;
+}
+StringColumnStatsData& StringColumnStatsData::operator=(const 
StringColumnStatsData& other294) {
+  maxColLen = other294.maxColLen;
+  avgColLen = other294.avgColLen;
+  numNulls = other294.numNulls;
+  numDVs = other294.numDVs;
+  bitVectors = other294.bitVectors;
+  __isset = other294.__isset;
   return *this;
 }
 void StringColumnStatsData::printTo(std::ostream& out) const {
@@ -7355,19 +7331,19 @@ void swap(BinaryColumnStatsData &a, 
BinaryColumnStatsData &b) {
   swap(a.__isset, b.__isset);
 }
 
-BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& 
other303) {
-  maxColLen = other303.maxColLen;
-  avgColLen = other303.avgColLen;
-  numNulls = other303.numNulls;
-  bitVectors = other303.bitVectors;
-  __isset = other303.__isset;
+BinaryColumnStatsData::BinaryColumnStatsData(const BinaryColumnStatsData& 
other295) {
+  maxColLen = other295.maxColLen;
+  avgColLen = other295.avgColLen;
+  numNulls = other295.numNulls;
+  bitVectors = other295.bitVectors;
+  __isset = other295.__isset;
 }
-BinaryColumnStatsData& BinaryColumnStatsData::operator=(const 
BinaryColumnStatsData& other304) {
-  maxColLen = other304.maxColLen;
-  avgColLen = other304.avgColLen;
-  numNulls = other304.numNulls;
-  bitVectors = other304.bitVectors;
-  __isset = other304.__isset;
+BinaryColumnStatsData& BinaryColumnStatsData::operator=(const 
BinaryColumnStatsData& other296) {
+  maxColLen = other296.maxColLen;
+  avgColLen = other296.avgColLen;
+  numNulls = other296.numNulls;
+  bitVectors = other296.bitVectors;
+  __isset = other296.__isset;
   return *this;
 }
 void BinaryColumnStatsData::printTo(std::ostream& out) const {
@@ -7472,13 +7448,13 @@ void swap(Decimal &a, Decimal &b) {
   swap(a.scale, b.scale);
 }
 
-Decimal::Decimal(const Decimal& other305) {
-  unscaled = other305.unscaled;
-  scale = other305.scale;
+Decimal::Decimal(const Decimal& other297) {
+  unscaled = other297.unscaled;
+  scale = other297.scale;
 }
-Decimal& Decimal::operator=(const Decimal& other306) {
-  unscaled = other306.unscaled;
-  scale = other306.scale;
+Decimal& Decimal::operator=(const Decimal& other298) {
+  unscaled = other298.unscaled;
+  scale = other298.scale;
   return *this;
 }
 void Decimal::printTo(std::ostream& out) const {
@@ -7639,21 +7615,21 @@ void swap(DecimalColumnStatsData &a, 
DecimalColumnStatsData &b) {
   swap(a.__isset, b.__isset);
 }
 
-DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& 
other307) {
-  lowValue = other307.lowValue;
-  highValue = other307.highValue;
-  numNulls = other307.numNulls;
-  numDVs = other307.numDVs;
-  bitVectors = other307.bitVectors;
-  __isset = other307.__isset;
-}
-DecimalColumnStatsData& DecimalColumnStatsData::operator=(const 
DecimalColumnStatsData& other308) {
-  lowValue = other308.lowValue;
-  highValue = other308.highValue;
-  numNulls = other308.numNulls;
-  numDVs = other308.numDVs;
-  bitVectors = other308.bitVectors;
-  __isset = other308.__isset;
+DecimalColumnStatsData::DecimalColumnStatsData(const DecimalColumnStatsData& 
other299) {
+  lowValue = other299.lowValue;
+  highValue = other299.highValue;
+  numNulls = other299.numNulls;
+  numDVs = other299.numDVs;
+  bitVectors = other299.bitVectors;
+  __isset = other299.__isset;
+}
+DecimalColumnStatsData& DecimalColumnStatsData::operator=(const 
DecimalColumnStatsData& other300) {
+  lowValue = other300.lowValue;
+  highValue = other300.highValue;
+  numNulls = other300.numNulls;
+  numDVs = other300.numDVs;
+  bitVectors = other300.bitVectors;
+  __isset = other300.__isset;
   return *this;
 }
 void DecimalColumnStatsData::printTo(std::ostream& out) const {
@@ -7739,11 +7715,11 @@ void swap(Date &a, Date &b) {
   swap(a.daysSinceEpoch, b.daysSinceEpoch);
 }
 
-Date::Date(const Date& other309) {
-  daysSinceEpoch = other309.daysSinceEpoch;
+Date::Date(const Date& other301) {
+  daysSinceEpoch = other301.daysSinceEpoch;
 }
-Date& Date::operator=(const Date& other310) {
-  daysSinceEpoch = other310.daysSinceEpoch;
+Date& Date::operator=(const Date& other302) {
+  daysSinceEpoch = other302.daysSinceEpoch;
   return *this;
 }
 void Date::printTo(std::ostream& out) const {
@@ -7903,21 +7879,21 @@ void swap(DateColumnStatsData &a, DateColumnStatsData 
&b) {
   swap(a.__isset, b.__isset);
 }
 
-DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other311) {
-  lowValue = other311.lowValue;
-  highValue = other311.highValue;
-  numNulls = other311.numNulls;
-  numDVs = other311.numDVs;
-  bitVectors = other311.bitVectors;
-  __isset = other311.__isset;
-}
-DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& 
other312) {
-  lowValue = other312.lowValue;
-  highValue = other312.highValue;
-  numNulls = other312.numNulls;
-  numDVs = other312.numDVs;
-  bitVectors = other312.bitVectors;
-  __isset = other312.__isset;
+DateColumnStatsData::DateColumnStatsData(const DateColumnStatsData& other303) {
+  lowValue = other303.lowValue;
+  highValue = other303.highValue;
+  numNulls = other303.numNulls;
+  numDVs = other303.numDVs;
+  bitVectors = other303.bitVectors;
+  __isset = other303.__isset;
+}
+DateColumnStatsData& DateColumnStatsData::operator=(const DateColumnStatsData& 
other304) {
+  lowValue = other304.lowValue;
+  highValue = other304.highValue;
+  numNulls = other304.numNulls;
+  numDVs = other304.numDVs;
+  bitVectors = other304.bitVectors;
+  __isset = other304.__isset;
   return *this;
 }
 void DateColumnStatsData::printTo(std::ostream& out) const {
@@ -8103,25 +8079,25 @@ void swap(ColumnStatisticsData &a, ColumnStatisticsData 
&b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& 
other313) {
-  booleanStats = other313.booleanStats;
-  longStats = other313.longStats;
-  doubleStats = other313.doubleStats;
-  stringStats = other313.stringStats;
-  binaryStats = other313.binaryStats;
-  decimalStats = other313.decimalStats;
-  dateStats = other313.dateStats;
-  __isset = other313.__isset;
-}
-ColumnStatisticsData& ColumnStatisticsData::operator=(const 
ColumnStatisticsData& other314) {
-  booleanStats = other314.booleanStats;
-  longStats = other314.longStats;
-  doubleStats = other314.doubleStats;
-  stringStats = other314.stringStats;
-  binaryStats = other314.binaryStats;
-  decimalStats = other314.decimalStats;
-  dateStats = other314.dateStats;
-  __isset = other314.__isset;
+ColumnStatisticsData::ColumnStatisticsData(const ColumnStatisticsData& 
other305) {
+  booleanStats = other305.booleanStats;
+  longStats = other305.longStats;
+  doubleStats = other305.doubleStats;
+  stringStats = other305.stringStats;
+  binaryStats = other305.binaryStats;
+  decimalStats = other305.decimalStats;
+  dateStats = other305.dateStats;
+  __isset = other305.__isset;
+}
+ColumnStatisticsData& ColumnStatisticsData::operator=(const 
ColumnStatisticsData& other306) {
+  booleanStats = other306.booleanStats;
+  longStats = other306.longStats;
+  doubleStats = other306.doubleStats;
+  stringStats = other306.stringStats;
+  binaryStats = other306.binaryStats;
+  decimalStats = other306.decimalStats;
+  dateStats = other306.dateStats;
+  __isset = other306.__isset;
   return *this;
 }
 void ColumnStatisticsData::printTo(std::ostream& out) const {
@@ -8249,15 +8225,15 @@ void swap(ColumnStatisticsObj &a, ColumnStatisticsObj 
&b) {
   swap(a.statsData, b.statsData);
 }
 
-ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other315) {
-  colName = other315.colName;
-  colType = other315.colType;
-  statsData = other315.statsData;
+ColumnStatisticsObj::ColumnStatisticsObj(const ColumnStatisticsObj& other307) {
+  colName = other307.colName;
+  colType = other307.colType;
+  statsData = other307.statsData;
 }
-ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& 
other316) {
-  colName = other316.colName;
-  colType = other316.colType;
-  statsData = other316.statsData;
+ColumnStatisticsObj& ColumnStatisticsObj::operator=(const ColumnStatisticsObj& 
other308) {
+  colName = other308.colName;
+  colType = other308.colType;
+  statsData = other308.statsData;
   return *this;
 }
 void ColumnStatisticsObj::printTo(std::ostream& out) const {
@@ -8420,21 +8396,21 @@ void swap(ColumnStatisticsDesc &a, ColumnStatisticsDesc 
&b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& 
other317) {
-  isTblLevel = other317.isTblLevel;
-  dbName = other317.dbName;
-  tableName = other317.tableName;
-  partName = other317.partName;
-  lastAnalyzed = other317.lastAnalyzed;
-  __isset = other317.__isset;
-}
-ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const 
ColumnStatisticsDesc& other318) {
-  isTblLevel = other318.isTblLevel;
-  dbName = other318.dbName;
-  tableName = other318.tableName;
-  partName = other318.partName;
-  lastAnalyzed = other318.lastAnalyzed;
-  __isset = other318.__isset;
+ColumnStatisticsDesc::ColumnStatisticsDesc(const ColumnStatisticsDesc& 
other309) {
+  isTblLevel = other309.isTblLevel;
+  dbName = other309.dbName;
+  tableName = other309.tableName;
+  partName = other309.partName;
+  lastAnalyzed = other309.lastAnalyzed;
+  __isset = other309.__isset;
+}
+ColumnStatisticsDesc& ColumnStatisticsDesc::operator=(const 
ColumnStatisticsDesc& other310) {
+  isTblLevel = other310.isTblLevel;
+  dbName = other310.dbName;
+  tableName = other310.tableName;
+  partName = other310.partName;
+  lastAnalyzed = other310.lastAnalyzed;
+  __isset = other310.__isset;
   return *this;
 }
 void ColumnStatisticsDesc::printTo(std::ostream& out) const {
@@ -8496,14 +8472,14 @@ uint32_t 
ColumnStatistics::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->statsObj.clear();
-            uint32_t _size319;
-            ::apache::thrift::protocol::TType _etype322;
-            xfer += iprot->readListBegin(_etype322, _size319);
-            this->statsObj.resize(_size319);
-            uint32_t _i323;
-            for (_i323 = 0; _i323 < _size319; ++_i323)
+            uint32_t _size311;
+            ::apache::thrift::protocol::TType _etype314;
+            xfer += iprot->readListBegin(_etype314, _size311);
+            this->statsObj.resize(_size311);
+            uint32_t _i315;
+            for (_i315 = 0; _i315 < _size311; ++_i315)
             {
-              xfer += this->statsObj[_i323].read(iprot);
+              xfer += this->statsObj[_i315].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8540,10 +8516,10 @@ uint32_t 
ColumnStatistics::write(::apache::thrift::protocol::TProtocol* oprot) c
   xfer += oprot->writeFieldBegin("statsObj", 
::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->statsObj.size()));
-    std::vector<ColumnStatisticsObj> ::const_iterator _iter324;
-    for (_iter324 = this->statsObj.begin(); _iter324 != this->statsObj.end(); 
++_iter324)
+    std::vector<ColumnStatisticsObj> ::const_iterator _iter316;
+    for (_iter316 = this->statsObj.begin(); _iter316 != this->statsObj.end(); 
++_iter316)
     {
-      xfer += (*_iter324).write(oprot);
+      xfer += (*_iter316).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8560,13 +8536,13 @@ void swap(ColumnStatistics &a, ColumnStatistics &b) {
   swap(a.statsObj, b.statsObj);
 }
 
-ColumnStatistics::ColumnStatistics(const ColumnStatistics& other325) {
-  statsDesc = other325.statsDesc;
-  statsObj = other325.statsObj;
+ColumnStatistics::ColumnStatistics(const ColumnStatistics& other317) {
+  statsDesc = other317.statsDesc;
+  statsObj = other317.statsObj;
 }
-ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& 
other326) {
-  statsDesc = other326.statsDesc;
-  statsObj = other326.statsObj;
+ColumnStatistics& ColumnStatistics::operator=(const ColumnStatistics& 
other318) {
+  statsDesc = other318.statsDesc;
+  statsObj = other318.statsObj;
   return *this;
 }
 void ColumnStatistics::printTo(std::ostream& out) const {
@@ -8617,14 +8593,14 @@ uint32_t 
AggrStats::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->colStats.clear();
-            uint32_t _size327;
-            ::apache::thrift::protocol::TType _etype330;
-            xfer += iprot->readListBegin(_etype330, _size327);
-            this->colStats.resize(_size327);
-            uint32_t _i331;
-            for (_i331 = 0; _i331 < _size327; ++_i331)
+            uint32_t _size319;
+            ::apache::thrift::protocol::TType _etype322;
+            xfer += iprot->readListBegin(_etype322, _size319);
+            this->colStats.resize(_size319);
+            uint32_t _i323;
+            for (_i323 = 0; _i323 < _size319; ++_i323)
             {
-              xfer += this->colStats[_i331].read(iprot);
+              xfer += this->colStats[_i323].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8665,10 +8641,10 @@ uint32_t 
AggrStats::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("colStats", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->colStats.size()));
-    std::vector<ColumnStatisticsObj> ::const_iterator _iter332;
-    for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); 
++_iter332)
+    std::vector<ColumnStatisticsObj> ::const_iterator _iter324;
+    for (_iter324 = this->colStats.begin(); _iter324 != this->colStats.end(); 
++_iter324)
     {
-      xfer += (*_iter332).write(oprot);
+      xfer += (*_iter324).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8689,13 +8665,13 @@ void swap(AggrStats &a, AggrStats &b) {
   swap(a.partsFound, b.partsFound);
 }
 
-AggrStats::AggrStats(const AggrStats& other333) {
-  colStats = other333.colStats;
-  partsFound = other333.partsFound;
+AggrStats::AggrStats(const AggrStats& other325) {
+  colStats = other325.colStats;
+  partsFound = other325.partsFound;
 }
-AggrStats& AggrStats::operator=(const AggrStats& other334) {
-  colStats = other334.colStats;
-  partsFound = other334.partsFound;
+AggrStats& AggrStats::operator=(const AggrStats& other326) {
+  colStats = other326.colStats;
+  partsFound = other326.partsFound;
   return *this;
 }
 void AggrStats::printTo(std::ostream& out) const {
@@ -8746,14 +8722,14 @@ uint32_t 
SetPartitionsStatsRequest::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->colStats.clear();
-            uint32_t _size335;
-            ::apache::thrift::protocol::TType _etype338;
-            xfer += iprot->readListBegin(_etype338, _size335);
-            this->colStats.resize(_size335);
-            uint32_t _i339;
-            for (_i339 = 0; _i339 < _size335; ++_i339)
+            uint32_t _size327;
+            ::apache::thrift::protocol::TType _etype330;
+            xfer += iprot->readListBegin(_etype330, _size327);
+            this->colStats.resize(_size327);
+            uint32_t _i331;
+            for (_i331 = 0; _i331 < _size327; ++_i331)
             {
-              xfer += this->colStats[_i339].read(iprot);
+              xfer += this->colStats[_i331].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8792,10 +8768,10 @@ uint32_t 
SetPartitionsStatsRequest::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("colStats", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->colStats.size()));
-    std::vector<ColumnStatistics> ::const_iterator _iter340;
-    for (_iter340 = this->colStats.begin(); _iter340 != this->colStats.end(); 
++_iter340)
+    std::vector<ColumnStatistics> ::const_iterator _iter332;
+    for (_iter332 = this->colStats.begin(); _iter332 != this->colStats.end(); 
++_iter332)
     {
-      xfer += (*_iter340).write(oprot);
+      xfer += (*_iter332).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8818,15 +8794,15 @@ void swap(SetPartitionsStatsRequest &a, 
SetPartitionsStatsRequest &b) {
   swap(a.__isset, b.__isset);
 }
 
-SetPartitionsStatsRequest::SetPartitionsStatsRequest(const 
SetPartitionsStatsRequest& other341) {
-  colStats = other341.colStats;
-  needMerge = other341.needMerge;
-  __isset = other341.__isset;
+SetPartitionsStatsRequest::SetPartitionsStatsRequest(const 
SetPartitionsStatsRequest& other333) {
+  colStats = other333.colStats;
+  needMerge = other333.needMerge;
+  __isset = other333.__isset;
 }
-SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const 
SetPartitionsStatsRequest& other342) {
-  colStats = other342.colStats;
-  needMerge = other342.needMerge;
-  __isset = other342.__isset;
+SetPartitionsStatsRequest& SetPartitionsStatsRequest::operator=(const 
SetPartitionsStatsRequest& other334) {
+  colStats = other334.colStats;
+  needMerge = other334.needMerge;
+  __isset = other334.__isset;
   return *this;
 }
 void SetPartitionsStatsRequest::printTo(std::ostream& out) const {
@@ -8875,14 +8851,14 @@ uint32_t 
Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->fieldSchemas.clear();
-            uint32_t _size343;
-            ::apache::thrift::protocol::TType _etype346;
-            xfer += iprot->readListBegin(_etype346, _size343);
-            this->fieldSchemas.resize(_size343);
-            uint32_t _i347;
-            for (_i347 = 0; _i347 < _size343; ++_i347)
+            uint32_t _size335;
+            ::apache::thrift::protocol::TType _etype338;
+            xfer += iprot->readListBegin(_etype338, _size335);
+            this->fieldSchemas.resize(_size335);
+            uint32_t _i339;
+            for (_i339 = 0; _i339 < _size335; ++_i339)
             {
-              xfer += this->fieldSchemas[_i347].read(iprot);
+              xfer += this->fieldSchemas[_i339].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -8895,17 +8871,17 @@ uint32_t 
Schema::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->properties.clear();
-            uint32_t _size348;
-            ::apache::thrift::protocol::TType _ktype349;
-            ::apache::thrift::protocol::TType _vtype350;
-            xfer += iprot->readMapBegin(_ktype349, _vtype350, _size348);
-            uint32_t _i352;
-            for (_i352 = 0; _i352 < _size348; ++_i352)
+            uint32_t _size340;
+            ::apache::thrift::protocol::TType _ktype341;
+            ::apache::thrift::protocol::TType _vtype342;
+            xfer += iprot->readMapBegin(_ktype341, _vtype342, _size340);
+            uint32_t _i344;
+            for (_i344 = 0; _i344 < _size340; ++_i344)
             {
-              std::string _key353;
-              xfer += iprot->readString(_key353);
-              std::string& _val354 = this->properties[_key353];
-              xfer += iprot->readString(_val354);
+              std::string _key345;
+              xfer += iprot->readString(_key345);
+              std::string& _val346 = this->properties[_key345];
+              xfer += iprot->readString(_val346);
             }
             xfer += iprot->readMapEnd();
           }
@@ -8934,10 +8910,10 @@ uint32_t 
Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("fieldSchemas", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->fieldSchemas.size()));
-    std::vector<FieldSchema> ::const_iterator _iter355;
-    for (_iter355 = this->fieldSchemas.begin(); _iter355 != 
this->fieldSchemas.end(); ++_iter355)
+    std::vector<FieldSchema> ::const_iterator _iter347;
+    for (_iter347 = this->fieldSchemas.begin(); _iter347 != 
this->fieldSchemas.end(); ++_iter347)
     {
-      xfer += (*_iter355).write(oprot);
+      xfer += (*_iter347).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -8946,11 +8922,11 @@ uint32_t 
Schema::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("properties", 
::apache::thrift::protocol::T_MAP, 2);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->properties.size()));
-    std::map<std::string, std::string> ::const_iterator _iter356;
-    for (_iter356 = this->properties.begin(); _iter356 != 
this->properties.end(); ++_iter356)
+    std::map<std::string, std::string> ::const_iterator _iter348;
+    for (_iter348 = this->properties.begin(); _iter348 != 
this->properties.end(); ++_iter348)
     {
-      xfer += oprot->writeString(_iter356->first);
-      xfer += oprot->writeString(_iter356->second);
+      xfer += oprot->writeString(_iter348->first);
+      xfer += oprot->writeString(_iter348->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -8968,15 +8944,15 @@ void swap(Schema &a, Schema &b) {
   swap(a.__isset, b.__isset);
 }
 
-Schema::Schema(const Schema& other357) {
-  fieldSchemas = other357.fieldSchemas;
-  properties = other357.properties;
-  __isset = other357.__isset;
+Schema::Schema(const Schema& other349) {
+  fieldSchemas = other349.fieldSchemas;
+  properties = other349.properties;
+  __isset = other349.__isset;
 }
-Schema& Schema::operator=(const Schema& other358) {
-  fieldSchemas = other358.fieldSchemas;
-  properties = other358.properties;
-  __isset = other358.__isset;
+Schema& Schema::operator=(const Schema& other350) {
+  fieldSchemas = other350.fieldSchemas;
+  properties = other350.properties;
+  __isset = other350.__isset;
   return *this;
 }
 void Schema::printTo(std::ostream& out) const {
@@ -9021,17 +8997,17 @@ uint32_t 
EnvironmentContext::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->properties.clear();
-            uint32_t _size359;
-            ::apache::thrift::protocol::TType _ktype360;
-            ::apache::thrift::protocol::TType _vtype361;
-            xfer += iprot->readMapBegin(_ktype360, _vtype361, _size359);
-            uint32_t _i363;
-            for (_i363 = 0; _i363 < _size359; ++_i363)
+            uint32_t _size351;
+            ::apache::thrift::protocol::TType _ktype352;
+            ::apache::thrift::protocol::TType _vtype353;
+            xfer += iprot->readMapBegin(_ktype352, _vtype353, _size351);
+            uint32_t _i355;
+            for (_i355 = 0; _i355 < _size351; ++_i355)
             {
-              std::string _key364;
-              xfer += iprot->readString(_key364);
-              std::string& _val365 = this->properties[_key364];
-              xfer += iprot->readString(_val365);
+              std::string _key356;
+              xfer += iprot->readString(_key356);
+              std::string& _val357 = this->properties[_key356];
+              xfer += iprot->readString(_val357);
             }
             xfer += iprot->readMapEnd();
           }
@@ -9060,11 +9036,11 @@ uint32_t 
EnvironmentContext::write(::apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("properties", 
::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, 
::apache::thrift::protocol::T_STRING, 
static_cast<uint32_t>(this->properties.size()));
-    std::map<std::string, std::string> ::const_iterator _iter366;
-    for (_iter366 = this->properties.begin(); _iter366 != 
this->properties.end(); ++_iter366)
+    std::map<std::string, std::string> ::const_iterator _iter358;
+    for (_iter358 = this->properties.begin(); _iter358 != 
this->properties.end(); ++_iter358)
     {
-      xfer += oprot->writeString(_iter366->first);
-      xfer += oprot->writeString(_iter366->second);
+      xfer += oprot->writeString(_iter358->first);
+      xfer += oprot->writeString(_iter358->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -9081,13 +9057,13 @@ void swap(EnvironmentContext &a, EnvironmentContext &b) 
{
   swap(a.__isset, b.__isset);
 }
 
-EnvironmentContext::EnvironmentContext(const EnvironmentContext& other367) {
-  properties = other367.properties;
-  __isset = other367.__isset;
+EnvironmentContext::EnvironmentContext(const EnvironmentContext& other359) {
+  properties = other359.properties;
+  __isset = other359.__isset;
 }
-EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& 
other368) {
-  properties = other368.properties;
-  __isset = other368.__isset;
+EnvironmentContext& EnvironmentContext::operator=(const EnvironmentContext& 
other360) {
+  properties = other360.properties;
+  __isset = other360.__isset;
   return *this;
 }
 void EnvironmentContext::printTo(std::ostream& out) const {
@@ -9189,13 +9165,13 @@ void swap(PrimaryKeysRequest &a, PrimaryKeysRequest &b) 
{
   swap(a.tbl_name, b.tbl_name);
 }
 
-PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other369) {
-  db_name = other369.db_name;
-  tbl_name = other369.tbl_name;
+PrimaryKeysRequest::PrimaryKeysRequest(const PrimaryKeysRequest& other361) {
+  db_name = other361.db_name;
+  tbl_name = other361.tbl_name;
 }
-PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& 
other370) {
-  db_name = other370.db_name;
-  tbl_name = other370.tbl_name;
+PrimaryKeysRequest& PrimaryKeysRequest::operator=(const PrimaryKeysRequest& 
other362) {
+  db_name = other362.db_name;
+  tbl_name = other362.tbl_name;
   return *this;
 }
 void PrimaryKeysRequest::printTo(std::ostream& out) const {
@@ -9241,14 +9217,14 @@ uint32_t 
PrimaryKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->primaryKeys.clear();
-            uint32_t _size371;
-            ::apache::thrift::protocol::TType _etype374;
-            xfer += iprot->readListBegin(_etype374, _size371);
-            this->primaryKeys.resize(_size371);
-            uint32_t _i375;
-            for (_i375 = 0; _i375 < _size371; ++_i375)
+            uint32_t _size363;
+            ::apache::thrift::protocol::TType _etype366;
+            xfer += iprot->readListBegin(_etype366, _size363);
+            this->primaryKeys.resize(_size363);
+            uint32_t _i367;
+            for (_i367 = 0; _i367 < _size363; ++_i367)
             {
-              xfer += this->primaryKeys[_i375].read(iprot);
+              xfer += this->primaryKeys[_i367].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -9279,10 +9255,10 @@ uint32_t 
PrimaryKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
   xfer += oprot->writeFieldBegin("primaryKeys", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->primaryKeys.size()));
-    std::vector<SQLPrimaryKey> ::const_iterator _iter376;
-    for (_iter376 = this->primaryKeys.begin(); _iter376 != 
this->primaryKeys.end(); ++_iter376)
+    std::vector<SQLPrimaryKey> ::const_iterator _iter368;
+    for (_iter368 = this->primaryKeys.begin(); _iter368 != 
this->primaryKeys.end(); ++_iter368)
     {
-      xfer += (*_iter376).write(oprot);
+      xfer += (*_iter368).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -9298,11 +9274,11 @@ void swap(PrimaryKeysResponse &a, PrimaryKeysResponse 
&b) {
   swap(a.primaryKeys, b.primaryKeys);
 }
 
-PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other377) {
-  primaryKeys = other377.primaryKeys;
+PrimaryKeysResponse::PrimaryKeysResponse(const PrimaryKeysResponse& other369) {
+  primaryKeys = other369.primaryKeys;
 }
-PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& 
other378) {
-  primaryKeys = other378.primaryKeys;
+PrimaryKeysResponse& PrimaryKeysResponse::operator=(const PrimaryKeysResponse& 
other370) {
+  primaryKeys = other370.primaryKeys;
   return *this;
 }
 void PrimaryKeysResponse::printTo(std::ostream& out) const {
@@ -9433,19 +9409,19 @@ void swap(ForeignKeysRequest &a, ForeignKeysRequest &b) 
{
   swap(a.__isset, b.__isset);
 }
 
-ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other379) {
-  parent_db_name = other379.parent_db_name;
-  parent_tbl_name = other379.parent_tbl_name;
-  foreign_db_name = other379.foreign_db_name;
-  foreign_tbl_name = other379.foreign_tbl_name;
-  __isset = other379.__isset;
+ForeignKeysRequest::ForeignKeysRequest(const ForeignKeysRequest& other371) {
+  parent_db_name = other371.parent_db_name;
+  parent_tbl_name = other371.parent_tbl_name;
+  foreign_db_name = other371.foreign_db_name;
+  foreign_tbl_name = other371.foreign_tbl_name;
+  __isset = other371.__isset;
 }
-ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& 
other380) {
-  parent_db_name = other380.parent_db_name;
-  parent_tbl_name = other380.parent_tbl_name;
-  foreign_db_name = other380.foreign_db_name;
-  foreign_tbl_name = other380.foreign_tbl_name;
-  __isset = other380.__isset;
+ForeignKeysRequest& ForeignKeysRequest::operator=(const ForeignKeysRequest& 
other372) {
+  parent_db_name = other372.parent_db_name;
+  parent_tbl_name = other372.parent_tbl_name;
+  foreign_db_name = other372.foreign_db_name;
+  foreign_tbl_name = other372.foreign_tbl_name;
+  __isset = other372.__isset;
   return *this;
 }
 void ForeignKeysRequest::printTo(std::ostream& out) const {
@@ -9493,14 +9469,14 @@ uint32_t 
ForeignKeysResponse::read(::apache::thrift::protocol::TProtocol* iprot)
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->foreignKeys.clear();
-            uint32_t _size381;
-            ::apache::thrift::protocol::TType _etype384;
-            xfer += iprot->readListBegin(_etype384, _size381);
-            this->foreignKeys.resize(_size381);
-            uint32_t _i385;
-            for (_i385 = 0; _i385 < _size381; ++_i385)
+            uint32_t _size373;
+            ::apache::thrift::protocol::TType _etype376;
+            xfer += iprot->readListBegin(_etype376, _size373);
+            this->foreignKeys.resize(_size373);
+            uint32_t _i377;
+            for (_i377 = 0; _i377 < _size373; ++_i377)
             {
-              xfer += this->foreignKeys[_i385].read(iprot);
+              xfer += this->foreignKeys[_i377].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -9531,10 +9507,10 @@ uint32_t 
ForeignKeysResponse::write(::apache::thrift::protocol::TProtocol* oprot
   xfer += oprot->writeFieldBegin("foreignKeys", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->foreignKeys.size()));
-    std::vector<SQLForeignKey> ::const_iterator _iter386;
-    for (_iter386 = this->foreignKeys.begin(); _iter386 != 
this->foreignKeys.end(); ++_iter386)
+    std::vector<SQLForeignKey> ::const_iterator _iter378;
+    for (_iter378 = this->foreignKeys.begin(); _iter378 != 
this->foreignKeys.end(); ++_iter378)
     {
-      xfer += (*_iter386).write(oprot);
+      xfer += (*_iter378).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -9550,11 +9526,11 @@ void swap(ForeignKeysResponse &a, ForeignKeysResponse 
&b) {
   swap(a.foreignKeys, b.foreignKeys);
 }
 
-ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other387) {
-  foreignKeys = other387.foreignKeys;
+ForeignKeysResponse::ForeignKeysResponse(const ForeignKeysResponse& other379) {
+  foreignKeys = other379.foreignKeys;
 }
-ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& 
other388) {
-  foreignKeys = other388.foreignKeys;
+ForeignKeysResponse& ForeignKeysResponse::operator=(const ForeignKeysResponse& 
other380) {
+  foreignKeys = other380.foreignKeys;
   return *this;
 }
 void ForeignKeysResponse::printTo(std::ostream& out) const {
@@ -9656,13 +9632,13 @@ void swap(UniqueConstraintsRequest &a, 
UniqueConstraintsRequest &b) {
   swap(a.tbl_name, b.tbl_name);
 }
 
-UniqueConstraintsRequest::UniqueConstraintsRequest(const 
UniqueConstraintsRequest& other389) {
-  db_name = other389.db_name;
-  tbl_name = other389.tbl_name;
+UniqueConstraintsRequest::UniqueConstraintsRequest(const 
UniqueConstraintsRequest& other381) {
+  db_name = other381.db_name;
+  tbl_name = other381.tbl_name;
 }
-UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const 
UniqueConstraintsRequest& other390) {
-  db_name = other390.db_name;
-  tbl_name = other390.tbl_name;
+UniqueConstraintsRequest& UniqueConstraintsRequest::operator=(const 
UniqueConstraintsRequest& other382) {
+  db_name = other382.db_name;
+  tbl_name = other382.tbl_name;
   return *this;
 }
 void UniqueConstraintsRequest::printTo(std::ostream& out) const {
@@ -9708,14 +9684,14 @@ uint32_t 
UniqueConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->uniqueConstraints.clear();
-            uint32_t _size391;
-            ::apache::thrift::protocol::TType _etype394;
-            xfer += iprot->readListBegin(_etype394, _size391);
-            this->uniqueConstraints.resize(_size391);
-            uint32_t _i395;
-            for (_i395 = 0; _i395 < _size391; ++_i395)
+            uint32_t _size383;
+            ::apache::thrift::protocol::TType _etype386;
+            xfer += iprot->readListBegin(_etype386, _size383);
+            this->uniqueConstraints.resize(_size383);
+            uint32_t _i387;
+            for (_i387 = 0; _i387 < _size383; ++_i387)
             {
-              xfer += this->uniqueConstraints[_i395].read(iprot);
+              xfer += this->uniqueConstraints[_i387].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -9746,10 +9722,10 @@ uint32_t 
UniqueConstraintsResponse::write(::apache::thrift::protocol::TProtocol*
   xfer += oprot->writeFieldBegin("uniqueConstraints", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->uniqueConstraints.size()));
-    std::vector<SQLUniqueConstraint> ::const_iterator _iter396;
-    for (_iter396 = this->uniqueConstraints.begin(); _iter396 != 
this->uniqueConstraints.end(); ++_iter396)
+    std::vector<SQLUniqueConstraint> ::const_iterator _iter388;
+    for (_iter388 = this->uniqueConstraints.begin(); _iter388 != 
this->uniqueConstraints.end(); ++_iter388)
     {
-      xfer += (*_iter396).write(oprot);
+      xfer += (*_iter388).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -9765,11 +9741,11 @@ void swap(UniqueConstraintsResponse &a, 
UniqueConstraintsResponse &b) {
   swap(a.uniqueConstraints, b.uniqueConstraints);
 }
 
-UniqueConstraintsResponse::UniqueConstraintsResponse(const 
UniqueConstraintsResponse& other397) {
-  uniqueConstraints = other397.uniqueConstraints;
+UniqueConstraintsResponse::UniqueConstraintsResponse(const 
UniqueConstraintsResponse& other389) {
+  uniqueConstraints = other389.uniqueConstraints;
 }
-UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const 
UniqueConstraintsResponse& other398) {
-  uniqueConstraints = other398.uniqueConstraints;
+UniqueConstraintsResponse& UniqueConstraintsResponse::operator=(const 
UniqueConstraintsResponse& other390) {
+  uniqueConstraints = other390.uniqueConstraints;
   return *this;
 }
 void UniqueConstraintsResponse::printTo(std::ostream& out) const {
@@ -9871,13 +9847,13 @@ void swap(NotNullConstraintsRequest &a, 
NotNullConstraintsRequest &b) {
   swap(a.tbl_name, b.tbl_name);
 }
 
-NotNullConstraintsRequest::NotNullConstraintsRequest(const 
NotNullConstraintsRequest& other399) {
-  db_name = other399.db_name;
-  tbl_name = other399.tbl_name;
+NotNullConstraintsRequest::NotNullConstraintsRequest(const 
NotNullConstraintsRequest& other391) {
+  db_name = other391.db_name;
+  tbl_name = other391.tbl_name;
 }
-NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const 
NotNullConstraintsRequest& other400) {
-  db_name = other400.db_name;
-  tbl_name = other400.tbl_name;
+NotNullConstraintsRequest& NotNullConstraintsRequest::operator=(const 
NotNullConstraintsRequest& other392) {
+  db_name = other392.db_name;
+  tbl_name = other392.tbl_name;
   return *this;
 }
 void NotNullConstraintsRequest::printTo(std::ostream& out) const {
@@ -9923,14 +9899,14 @@ uint32_t 
NotNullConstraintsResponse::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->notNullConstraints.clear();
-            uint32_t _size401;
-            ::apache::thrift::protocol::TType _etype404;
-            xfer += iprot->readListBegin(_etype404, _size401);
-            this->notNullConstraints.resize(_size401);
-            uint32_t _i405;
-            for (_i405 = 0; _i405 < _size401; ++_i405)
+            uint32_t _size393;
+            ::apache::thrift::protocol::TType _etype396;
+            xfer += iprot->readListBegin(_etype396, _size393);
+            this->notNullConstraints.resize(_size393);
+            uint32_t _i397;
+            for (_i397 = 0; _i397 < _size393; ++_i397)
             {
-              xfer += this->notNullConstraints[_i405].read(iprot);
+              xfer += this->notNullConstraints[_i397].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -9961,10 +9937,10 @@ uint32_t 
NotNullConstraintsResponse::write(::apache::thrift::protocol::TProtocol
   xfer += oprot->writeFieldBegin("notNullConstraints", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->notNullConstraints.size()));
-    std::vector<SQLNotNullConstraint> ::const_iterator _iter406;
-    for (_iter406 = this->notNullConstraints.begin(); _iter406 != 
this->notNullConstraints.end(); ++_iter406)
+    std::vector<SQLNotNullConstraint> ::const_iterator _iter398;
+    for (_iter398 = this->notNullConstraints.begin(); _iter398 != 
this->notNullConstraints.end(); ++_iter398)
     {
-      xfer += (*_iter406).write(oprot);
+      xfer += (*_iter398).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -9980,11 +9956,11 @@ void swap(NotNullConstraintsResponse &a, 
NotNullConstraintsResponse &b) {
   swap(a.notNullConstraints, b.notNullConstraints);
 }
 
-NotNullConstraintsResponse::NotNullConstraintsResponse(const 
NotNullConstraintsResponse& other407) {
-  notNullConstraints = other407.notNullConstraints;
+NotNullConstraintsResponse::NotNullConstraintsResponse(const 
NotNullConstraintsResponse& other399) {
+  notNullConstraints = other399.notNullConstraints;
 }
-NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const 
NotNullConstraintsResponse& other408) {
-  notNullConstraints = other408.notNullConstraints;
+NotNullConstraintsResponse& NotNullConstraintsResponse::operator=(const 
NotNullConstraintsResponse& other400) {
+  notNullConstraints = other400.notNullConstraints;
   return *this;
 }
 void NotNullConstraintsResponse::printTo(std::ostream& out) const {
@@ -10106,15 +10082,15 @@ void swap(DropConstraintRequest &a, 
DropConstraintRequest &b) {
   swap(a.constraintname, b.constraintname);
 }
 
-DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& 
other409) {
-  dbname = other409.dbname;
-  tablename = other409.tablename;
-  constraintname = other409.constraintname;
+DropConstraintRequest::DropConstraintRequest(const DropConstraintRequest& 
other401) {
+  dbname = other401.dbname;
+  tablename = other401.tablename;
+  constraintname = other401.constraintname;
 }
-DropConstraintRequest& DropConstraintRequest::operator=(const 
DropConstraintRequest& other410) {
-  dbname = other410.dbname;
-  tablename = other410.tablename;
-  constraintname = other410.constraintname;
+DropConstraintRequest& DropConstraintRequest::operator=(const 
DropConstraintRequest& other402) {
+  dbname = other402.dbname;
+  tablename = other402.tablename;
+  constraintname = other402.constraintname;
   return *this;
 }
 void DropConstraintRequest::printTo(std::ostream& out) const {
@@ -10161,14 +10137,14 @@ uint32_t 
AddPrimaryKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->primaryKeyCols.clear();
-            uint32_t _size411;
-            ::apache::thrift::protocol::TType _etype414;
-            xfer += iprot->readListBegin(_etype414, _size411);
-            this->primaryKeyCols.resize(_size411);
-            uint32_t _i415;
-            for (_i415 = 0; _i415 < _size411; ++_i415)
+            uint32_t _size403;
+            ::apache::thrift::protocol::TType _etype406;
+            xfer += iprot->readListBegin(_etype406, _size403);
+            this->primaryKeyCols.resize(_size403);
+            uint32_t _i407;
+            for (_i407 = 0; _i407 < _size403; ++_i407)
             {
-              xfer += this->primaryKeyCols[_i415].read(iprot);
+              xfer += this->primaryKeyCols[_i407].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -10199,10 +10175,10 @@ uint32_t 
AddPrimaryKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
   xfer += oprot->writeFieldBegin("primaryKeyCols", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->primaryKeyCols.size()));
-    std::vector<SQLPrimaryKey> ::const_iterator _iter416;
-    for (_iter416 = this->primaryKeyCols.begin(); _iter416 != 
this->primaryKeyCols.end(); ++_iter416)
+    std::vector<SQLPrimaryKey> ::const_iterator _iter408;
+    for (_iter408 = this->primaryKeyCols.begin(); _iter408 != 
this->primaryKeyCols.end(); ++_iter408)
     {
-      xfer += (*_iter416).write(oprot);
+      xfer += (*_iter408).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -10218,11 +10194,11 @@ void swap(AddPrimaryKeyRequest &a, 
AddPrimaryKeyRequest &b) {
   swap(a.primaryKeyCols, b.primaryKeyCols);
 }
 
-AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& 
other417) {
-  primaryKeyCols = other417.primaryKeyCols;
+AddPrimaryKeyRequest::AddPrimaryKeyRequest(const AddPrimaryKeyRequest& 
other409) {
+  primaryKeyCols = other409.primaryKeyCols;
 }
-AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const 
AddPrimaryKeyRequest& other418) {
-  primaryKeyCols = other418.primaryKeyCols;
+AddPrimaryKeyRequest& AddPrimaryKeyRequest::operator=(const 
AddPrimaryKeyRequest& other410) {
+  primaryKeyCols = other410.primaryKeyCols;
   return *this;
 }
 void AddPrimaryKeyRequest::printTo(std::ostream& out) const {
@@ -10267,14 +10243,14 @@ uint32_t 
AddForeignKeyRequest::read(::apache::thrift::protocol::TProtocol* iprot
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->foreignKeyCols.clear();
-            uint32_t _size419;
-            ::apache::thrift::protocol::TType _etype422;
-            xfer += iprot->readListBegin(_etype422, _size419);
-            this->foreignKeyCols.resize(_size419);
-            uint32_t _i423;
-            for (_i423 = 0; _i423 < _size419; ++_i423)
+            uint32_t _size411;
+            ::apache::thrift::protocol::TType _etype414;
+            xfer += iprot->readListBegin(_etype414, _size411);
+            this->foreignKeyCols.resize(_size411);
+            uint32_t _i415;
+            for (_i415 = 0; _i415 < _size411; ++_i415)
             {
-              xfer += this->foreignKeyCols[_i423].read(iprot);
+              xfer += this->foreignKeyCols[_i415].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -10305,10 +10281,10 @@ uint32_t 
AddForeignKeyRequest::write(::apache::thrift::protocol::TProtocol* opro
   xfer += oprot->writeFieldBegin("foreignKeyCols", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->foreignKeyCols.size()));
-    std::vector<SQLForeignKey> ::const_iterator _iter424;
-    for (_iter424 = this->foreignKeyCols.begin(); _iter424 != 
this->foreignKeyCols.end(); ++_iter424)
+    std::vector<SQLForeignKey> ::const_iterator _iter416;
+    for (_iter416 = this->foreignKeyCols.begin(); _iter416 != 
this->foreignKeyCols.end(); ++_iter416)
     {
-      xfer += (*_iter424).write(oprot);
+      xfer += (*_iter416).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -10324,11 +10300,11 @@ void swap(AddForeignKeyRequest &a, 
AddForeignKeyRequest &b) {
   swap(a.foreignKeyCols, b.foreignKeyCols);
 }
 
-AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& 
other425) {
-  foreignKeyCols = other425.foreignKeyCols;
+AddForeignKeyRequest::AddForeignKeyRequest(const AddForeignKeyRequest& 
other417) {
+  foreignKeyCols = other417.foreignKeyCols;
 }
-AddForeignKeyRequest& AddForeignKeyRequest::operator=(const 
AddForeignKeyRequest& other426) {
-  foreignKeyCols = other426.foreignKeyCols;
+AddForeignKeyRequest& AddForeignKeyRequest::operator=(const 
AddForeignKeyRequest& other418) {
+  foreignKeyCols = other418.foreignKeyCols;
   return *this;
 }
 void AddForeignKeyRequest::printTo(std::ostream& out) const {
@@ -10373,14 +10349,14 @@ uint32_t 
AddUniqueConstraintRequest::read(::apache::thrift::protocol::TProtocol*
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->uniqueConstraintCols.clear();
-            uint32_t _size427;
-            ::apache::thrift::protocol::TType _etype430;
-            xfer += iprot->readListBegin(_etype430, _size427);
-            this->uniqueConstraintCols.resize(_size427);
-            uint32_t _i431;
-            for (_i431 = 0; _i431 < _size427; ++_i431)
+            uint32_t _size419;
+            ::apache::thrift::protocol::TType _etype422;
+            xfer += iprot->readListBegin(_etype422, _size419);
+            this->uniqueConstraintCols.resize(_size419);
+            uint32_t _i423;
+            for (_i423 = 0; _i423 < _size419; ++_i423)
             {
-              xfer += this->uniqueConstraintCols[_i431].read(iprot);
+              xfer += this->uniqueConstraintCols[_i423].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -10411,10 +10387,10 @@ uint32_t 
AddUniqueConstraintRequest::write(::apache::thrift::protocol::TProtocol
   xfer += oprot->writeFieldBegin("uniqueConstraintCols", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->uniqueConstraintCols.size()));
-    std::vector<SQLUniqueConstraint> ::const_iterator _iter432;
-    for (_iter432 = this->uniqueConstraintCols.begin(); _iter432 != 
this->uniqueConstraintCols.end(); ++_iter432)
+    std::vector<SQLUniqueConstraint> ::const_iterator _iter424;
+    for (_iter424 = this->uniqueConstraintCols.begin(); _iter424 != 
this->uniqueConstraintCols.end(); ++_iter424)
     {
-      xfer += (*_iter432).write(oprot);
+      xfer += (*_iter424).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -10430,11 +10406,11 @@ void swap(AddUniqueConstraintRequest &a, 
AddUniqueConstraintRequest &b) {
   swap(a.uniqueConstraintCols, b.uniqueConstraintCols);
 }
 
-AddUniqueConstraintRequest::AddUniqueConstraintRequest(const 
AddUniqueConstraintRequest& other433) {
-  uniqueConstraintCols = other433.uniqueConstraintCols;
+AddUniqueConstraintRequest::AddUniqueConstraintRequest(const 
AddUniqueConstraintRequest& other425) {
+  uniqueConstraintCols = other425.uniqueConstraintCols;
 }
-AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const 
AddUniqueConstraintRequest& other434) {
-  uniqueConstraintCols = other434.uniqueConstraintCols;
+AddUniqueConstraintRequest& AddUniqueConstraintRequest::operator=(const 
AddUniqueConstraintRequest& other426) {
+  uniqueConstraintCols = other426.uniqueConstraintCols;
   return *this;
 }
 void AddUniqueConstraintRequest::printTo(std::ostream& out) const {
@@ -10479,14 +10455,14 @@ uint32_t 
AddNotNullConstraintRequest::read(::apache::thrift::protocol::TProtocol
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->notNullConstraintCols.clear();
-            uint32_t _size435;
-            ::apache::thrift::protocol::TType _etype438;
-            xfer += iprot->readListBegin(_etype438, _size435);
-            this->notNullConstraintCols.resize(_size435);
-            uint32_t _i439;
-            for (_i439 = 0; _i439 < _size435; ++_i439)
+            uint32_t _size427;
+            ::apache::thrift::protocol::TType _etype430;
+            xfer += iprot->readListBegin(_etype430, _size427);
+            this->notNullConstraintCols.resize(_size427);
+            uint32_t _i431;
+            for (_i431 = 0; _i431 < _size427; ++_i431)
             {
-              xfer += this->notNullConstraintCols[_i439].read(iprot);
+              xfer += this->notNullConstraintCols[_i431].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -10517,10 +10493,10 @@ uint32_t 
AddNotNullConstraintRequest::write(::apache::thrift::protocol::TProtoco
   xfer += oprot->writeFieldBegin("notNullConstraintCols", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->notNullConstraintCols.size()));
-    std::vector<SQLNotNullConstraint> ::const_iterator _iter440;
-    for (_iter440 = this->notNullConstraintCols.begin(); _iter440 != 
this->notNullConstraintCols.end(); ++_iter440)
+    std::vector<SQLNotNullConstraint> ::const_iterator _iter432;
+    for (_iter432 = this->notNullConstraintCols.begin(); _iter432 != 
this->notNullConstraintCols.end(); ++_iter432)
     {
-      xfer += (*_iter440).write(oprot);
+      xfer += (*_iter432).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -10536,11 +10512,11 @@ void swap(AddNotNullConstraintRequest &a, 
AddNotNullConstraintRequest &b) {
   swap(a.notNullConstraintCols, b.notNullConstraintCols);
 }
 
-AddNotNullConstraintRequest::AddNotNullConstraintRequest(const 
AddNotNullConstraintRequest& other441) {
-  notNullConstraintCols = other441.notNullConstraintCols;
+AddNotNullConstraintRequest::AddNotNullConstraintRequest(const 
AddNotNullConstraintRequest& other433) {
+  notNullConstraintCols = other433.notNullConstraintCols;
 }
-AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const 
AddNotNullConstraintRequest& other442) {
-  notNullConstraintCols = other442.notNullConstraintCols;
+AddNotNullConstraintRequest& AddNotNullConstraintRequest::operator=(const 
AddNotNullConstraintRequest& other434) {
+  notNullConstraintCols = other434.notNullConstraintCols;
   return *this;
 }
 void AddNotNullConstraintRequest::printTo(std::ostream& out) const {
@@ -10590,14 +10566,14 @@ uint32_t 
PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* ipr
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->partitions.clear();
-            uint32_t _size443;
-            ::apache::thrift::protocol::TType _etype446;
-            xfer += iprot->readListBegin(_etype446, _size443);
-            this->partitions.resize(_size443);
-            uint32_t _i447;
-            for (_i447 = 0; _i447 < _size443; ++_i447)
+            uint32_t _size435;
+            ::apache::thrift::protocol::TType _etype438;
+            xfer += iprot->readListBegin(_etype438, _size435);
+            this->partitions.resize(_size435);
+            uint32_t _i439;
+            for (_i439 = 0; _i439 < _size435; ++_i439)
             {
-              xfer += this->partitions[_i447].read(iprot);
+              xfer += this->partitions[_i439].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -10638,10 +10614,10 @@ uint32_t 
PartitionsByExprResult::write(::apache::thrift::protocol::TProtocol* op
   xfer += oprot->writeFieldBegin("partitions", 
::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(this->partitions.size()));
-    std::vector<Partition> ::const_iterator _iter448;
-    for (_iter448 = this->partitions.begin(); _iter448 != 
this->partitions.end(); ++_iter448)
+    std::vector<Partition> ::const_iterator _iter440;
+    for (_iter440 = this->partitions.begin(); _iter440 != 
this->partitions.end(); ++_iter440)
     {
-      xfer += (*_iter448).write(oprot);
+      xfer += (*_iter440).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -10662,13 +10638,13 @@ void swap(PartitionsByExprResult &a, 
PartitionsByExprResult &b) {
   swap(a.hasUnknownPartitions, b.hasUnknownPartitions);
 }
 
-PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& 
other449) {
-  partitions = other449.partitions;
-  hasUnknownPartitions = other449.hasUnknownPartitions;
+PartitionsByExprResult::PartitionsByExprResult(const PartitionsByExprResult& 
other441) {
+  partitions = other441.partitions;
+  hasUnknownPartitions = other441.hasUnknownPartitions;
 }
-PartitionsByExprResult& PartitionsByExprResult::operator=(const 
PartitionsByExprResult& other450) {
-  partitions = other450.partitions;
-  hasUnknownPartitions = other450.hasUnknownPartitions;
+PartitionsByExprResult& PartitionsByExprResult::operator=(const 
PartitionsByExprResult& other442) {
+  partitions = other442.partitions;
+  hasUnknownPartitions = other442.hasUnknownPartitions;
   return *this;
 }
 void PartitionsByExprResult::printTo(std::ostream& out) const {
@@ -10830,21 +10806,21 @@ void swap(PartitionsByExprRequest &a, 
PartitionsByExprRequest &b) {
   swap(a.__isset, b.__isset);
 }
 
-PartitionsByExprRequest::PartitionsByExprRequest(const 
PartitionsByExprRequest& other451) {
-  dbName = other451.dbName;
-  tblName = other451.tblName;
-  expr = other451.expr;
-  defaultPartitionName = other451.defaultPartitionName;
-  maxParts = other451.maxParts;

<TRUNCATED>

Reply via email to