Return-Path: 
 <commits-return-16385-apmail-hive-commits-archive=hive.apache.org@hive.apache.org>
X-Original-To: apmail-hive-commits-archive@www.apache.org
Delivered-To: apmail-hive-commits-archive@www.apache.org
Received: from mail.apache.org (hermes.apache.org [140.211.11.3])
	by minotaur.apache.org (Postfix) with SMTP id 207A517EE0
	for <apmail-hive-commits-archive@www.apache.org>;
 Sun,  2 Aug 2015 03:58:56 +0000 (UTC)
Received: (qmail 20039 invoked by uid 500); 2 Aug 2015 03:58:50 -0000
Delivered-To: apmail-hive-commits-archive@hive.apache.org
Received: (qmail 19928 invoked by uid 500); 2 Aug 2015 03:58:50 -0000
Mailing-List: contact commits-help@hive.apache.org; run by ezmlm
Precedence: bulk
List-Help: <mailto:commits-help@hive.apache.org>
List-Unsubscribe: <mailto:commits-unsubscribe@hive.apache.org>
List-Post: <mailto:commits@hive.apache.org>
List-Id: <commits.hive.apache.org>
Reply-To: hive-dev@hive.apache.org
Delivered-To: mailing list commits@hive.apache.org
Received: (qmail 16701 invoked by uid 99); 2 Aug 2015 03:58:47 -0000
Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org)
 (140.211.11.23)
    by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 02 Aug 2015 03:58:47 +0000
Received: by git1-us-west.apache.org (ASF Mail Server at
 git1-us-west.apache.org, from userid 33)
	id AFDD1E09FB; Sun,  2 Aug 2015 03:58:47 +0000 (UTC)
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: xuefu@apache.org
To: commits@hive.apache.org
Date: Sun, 02 Aug 2015 03:59:30 -0000
Message-Id: <4baecebd86db45adbdc14aecfcac1cfc@git.apache.org>
In-Reply-To: <e5b58b6c943a4cb59d4a3f2b598eda75@git.apache.org>
References: <e5b58b6c943a4cb59d4a3f2b598eda75@git.apache.org>
X-Mailer: ASF-Git Admin Mailer
Subject: [45/50] hive git commit: HIVE-9152 - Dynamic Partition Pruning [Spark
 Branch] (Chao Sun, reviewed by Xuefu Zhang and Chengxiang Li)

http://git-wip-us.apache.org/repos/asf/hive/blob/d7413e4b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
index d405446..91f8b56 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.9.0)
+ * Autogenerated by Thrift Compiler (0.9.2)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -7,6 +7,9 @@
 #include "hive_metastore_types.h"
 
 #include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
 
 namespace Apache { namespace Hadoop { namespace Hive {
 
@@ -148,6 +151,19 @@ const char* _kResourceTypeNames[] = {
 };
 const std::map<int, const char*> _ResourceType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kResourceTypeValues, _kResourceTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
 
+
+Version::~Version() throw() {
+}
+
+
+void Version::__set_version(const std::string& val) {
+  this->version = val;
+}
+
+void Version::__set_comments(const std::string& val) {
+  this->comments = val;
+}
+
 const char* Version::ascii_fingerprint = "07A9615F837F7D0A952B595DD3020972";
 const uint8_t Version::binary_fingerprint[16] = {0x07,0xA9,0x61,0x5F,0x83,0x7F,0x7D,0x0A,0x95,0x2B,0x59,0x5D,0xD3,0x02,0x09,0x72};
 
@@ -201,6 +217,7 @@ uint32_t Version::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Version::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Version");
 
   xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_STRING, 1);
@@ -213,6 +230,7 @@ uint32_t Version::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -223,6 +241,43 @@ void swap(Version &a, Version &b) {
   swap(a.__isset, b.__isset);
 }
 
+Version::Version(const Version& other0) {
+  version = other0.version;
+  comments = other0.comments;
+  __isset = other0.__isset;
+}
+Version& Version::operator=(const Version& other1) {
+  version = other1.version;
+  comments = other1.comments;
+  __isset = other1.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Version& obj) {
+  using apache::thrift::to_string;
+  out << "Version(";
+  out << "version=" << to_string(obj.version);
+  out << ", " << "comments=" << to_string(obj.comments);
+  out << ")";
+  return out;
+}
+
+
+FieldSchema::~FieldSchema() throw() {
+}
+
+
+void FieldSchema::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void FieldSchema::__set_type(const std::string& val) {
+  this->type = val;
+}
+
+void FieldSchema::__set_comment(const std::string& val) {
+  this->comment = val;
+}
+
 const char* FieldSchema::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271";
 const uint8_t FieldSchema::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71};
 
@@ -284,6 +339,7 @@ uint32_t FieldSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t FieldSchema::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("FieldSchema");
 
   xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
@@ -300,6 +356,7 @@ uint32_t FieldSchema::write(::apache::thrift::protocol::TProtocol* oprot) const
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -311,6 +368,53 @@ void swap(FieldSchema &a, FieldSchema &b) {
   swap(a.__isset, b.__isset);
 }
 
+FieldSchema::FieldSchema(const FieldSchema& other2) {
+  name = other2.name;
+  type = other2.type;
+  comment = other2.comment;
+  __isset = other2.__isset;
+}
+FieldSchema& FieldSchema::operator=(const FieldSchema& other3) {
+  name = other3.name;
+  type = other3.type;
+  comment = other3.comment;
+  __isset = other3.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const FieldSchema& obj) {
+  using apache::thrift::to_string;
+  out << "FieldSchema(";
+  out << "name=" << to_string(obj.name);
+  out << ", " << "type=" << to_string(obj.type);
+  out << ", " << "comment=" << to_string(obj.comment);
+  out << ")";
+  return out;
+}
+
+
+Type::~Type() throw() {
+}
+
+
+void Type::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void Type::__set_type1(const std::string& val) {
+  this->type1 = val;
+__isset.type1 = true;
+}
+
+void Type::__set_type2(const std::string& val) {
+  this->type2 = val;
+__isset.type2 = true;
+}
+
+void Type::__set_fields(const std::vector<FieldSchema> & val) {
+  this->fields = val;
+__isset.fields = true;
+}
+
 const char* Type::ascii_fingerprint = "20DF02DE523C27F7066C7BD4D9120842";
 const uint8_t Type::binary_fingerprint[16] = {0x20,0xDF,0x02,0xDE,0x52,0x3C,0x27,0xF7,0x06,0x6C,0x7B,0xD4,0xD9,0x12,0x08,0x42};
 
@@ -362,14 +466,14 @@ uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->fields.clear();
-            uint32_t _size0;
-            ::apache::thrift::protocol::TType _etype3;
-            xfer += iprot->readListBegin(_etype3, _size0);
-            this->fields.resize(_size0);
-            uint32_t _i4;
-            for (_i4 = 0; _i4 < _size0; ++_i4)
+            uint32_t _size4;
+            ::apache::thrift::protocol::TType _etype7;
+            xfer += iprot->readListBegin(_etype7, _size4);
+            this->fields.resize(_size4);
+            uint32_t _i8;
+            for (_i8 = 0; _i8 < _size4; ++_i8)
             {
-              xfer += this->fields[_i4].read(iprot);
+              xfer += this->fields[_i8].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -392,6 +496,7 @@ uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Type");
 
   xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
@@ -412,10 +517,10 @@ uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fields.size()));
-      std::vector<FieldSchema> ::const_iterator _iter5;
-      for (_iter5 = this->fields.begin(); _iter5 != this->fields.end(); ++_iter5)
+      std::vector<FieldSchema> ::const_iterator _iter9;
+      for (_iter9 = this->fields.begin(); _iter9 != this->fields.end(); ++_iter9)
       {
-        xfer += (*_iter5).write(oprot);
+        xfer += (*_iter9).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -423,6 +528,7 @@ uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -435,6 +541,57 @@ void swap(Type &a, Type &b) {
   swap(a.__isset, b.__isset);
 }
 
+Type::Type(const Type& other10) {
+  name = other10.name;
+  type1 = other10.type1;
+  type2 = other10.type2;
+  fields = other10.fields;
+  __isset = other10.__isset;
+}
+Type& Type::operator=(const Type& other11) {
+  name = other11.name;
+  type1 = other11.type1;
+  type2 = other11.type2;
+  fields = other11.fields;
+  __isset = other11.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Type& obj) {
+  using apache::thrift::to_string;
+  out << "Type(";
+  out << "name=" << to_string(obj.name);
+  out << ", " << "type1="; (obj.__isset.type1 ? (out << to_string(obj.type1)) : (out << "<null>"));
+  out << ", " << "type2="; (obj.__isset.type2 ? (out << to_string(obj.type2)) : (out << "<null>"));
+  out << ", " << "fields="; (obj.__isset.fields ? (out << to_string(obj.fields)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+HiveObjectRef::~HiveObjectRef() throw() {
+}
+
+
+void HiveObjectRef::__set_objectType(const HiveObjectType::type val) {
+  this->objectType = val;
+}
+
+void HiveObjectRef::__set_dbName(const std::string& val) {
+  this->dbName = val;
+}
+
+void HiveObjectRef::__set_objectName(const std::string& val) {
+  this->objectName = val;
+}
+
+void HiveObjectRef::__set_partValues(const std::vector<std::string> & val) {
+  this->partValues = val;
+}
+
+void HiveObjectRef::__set_columnName(const std::string& val) {
+  this->columnName = val;
+}
+
 const char* HiveObjectRef::ascii_fingerprint = "205CD8311CF3AA9EC161BAEF8D7C933C";
 const uint8_t HiveObjectRef::binary_fingerprint[16] = {0x20,0x5C,0xD8,0x31,0x1C,0xF3,0xAA,0x9E,0xC1,0x61,0xBA,0xEF,0x8D,0x7C,0x93,0x3C};
 
@@ -460,9 +617,9 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast6;
-          xfer += iprot->readI32(ecast6);
-          this->objectType = (HiveObjectType::type)ecast6;
+          int32_t ecast12;
+          xfer += iprot->readI32(ecast12);
+          this->objectType = (HiveObjectType::type)ecast12;
           this->__isset.objectType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -488,14 +645,14 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->partValues.clear();
-            uint32_t _size7;
-            ::apache::thrift::protocol::TType _etype10;
-            xfer += iprot->readListBegin(_etype10, _size7);
-            this->partValues.resize(_size7);
-            uint32_t _i11;
-            for (_i11 = 0; _i11 < _size7; ++_i11)
+            uint32_t _size13;
+            ::apache::thrift::protocol::TType _etype16;
+            xfer += iprot->readListBegin(_etype16, _size13);
+            this->partValues.resize(_size13);
+            uint32_t _i17;
+            for (_i17 = 0; _i17 < _size13; ++_i17)
             {
-              xfer += iprot->readString(this->partValues[_i11]);
+              xfer += iprot->readString(this->partValues[_i17]);
             }
             xfer += iprot->readListEnd();
           }
@@ -526,6 +683,7 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("HiveObjectRef");
 
   xfer += oprot->writeFieldBegin("objectType", ::apache::thrift::protocol::T_I32, 1);
@@ -543,10 +701,10 @@ uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) cons
   xfer += oprot->writeFieldBegin("partValues", ::apache::thrift::protocol::T_LIST, 4);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partValues.size()));
-    std::vector<std::string> ::const_iterator _iter12;
-    for (_iter12 = this->partValues.begin(); _iter12 != this->partValues.end(); ++_iter12)
+    std::vector<std::string> ::const_iterator _iter18;
+    for (_iter18 = this->partValues.begin(); _iter18 != this->partValues.end(); ++_iter18)
     {
-      xfer += oprot->writeString((*_iter12));
+      xfer += oprot->writeString((*_iter18));
     }
     xfer += oprot->writeListEnd();
   }
@@ -558,6 +716,7 @@ uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) cons
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -571,6 +730,60 @@ void swap(HiveObjectRef &a, HiveObjectRef &b) {
   swap(a.__isset, b.__isset);
 }
 
+HiveObjectRef::HiveObjectRef(const HiveObjectRef& other19) {
+  objectType = other19.objectType;
+  dbName = other19.dbName;
+  objectName = other19.objectName;
+  partValues = other19.partValues;
+  columnName = other19.columnName;
+  __isset = other19.__isset;
+}
+HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other20) {
+  objectType = other20.objectType;
+  dbName = other20.dbName;
+  objectName = other20.objectName;
+  partValues = other20.partValues;
+  columnName = other20.columnName;
+  __isset = other20.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const HiveObjectRef& obj) {
+  using apache::thrift::to_string;
+  out << "HiveObjectRef(";
+  out << "objectType=" << to_string(obj.objectType);
+  out << ", " << "dbName=" << to_string(obj.dbName);
+  out << ", " << "objectName=" << to_string(obj.objectName);
+  out << ", " << "partValues=" << to_string(obj.partValues);
+  out << ", " << "columnName=" << to_string(obj.columnName);
+  out << ")";
+  return out;
+}
+
+
+PrivilegeGrantInfo::~PrivilegeGrantInfo() throw() {
+}
+
+
+void PrivilegeGrantInfo::__set_privilege(const std::string& val) {
+  this->privilege = val;
+}
+
+void PrivilegeGrantInfo::__set_createTime(const int32_t val) {
+  this->createTime = val;
+}
+
+void PrivilegeGrantInfo::__set_grantor(const std::string& val) {
+  this->grantor = val;
+}
+
+void PrivilegeGrantInfo::__set_grantorType(const PrincipalType::type val) {
+  this->grantorType = val;
+}
+
+void PrivilegeGrantInfo::__set_grantOption(const bool val) {
+  this->grantOption = val;
+}
+
 const char* PrivilegeGrantInfo::ascii_fingerprint = "A58923AF7294BE492D6F90E07E8CEE1F";
 const uint8_t PrivilegeGrantInfo::binary_fingerprint[16] = {0xA5,0x89,0x23,0xAF,0x72,0x94,0xBE,0x49,0x2D,0x6F,0x90,0xE0,0x7E,0x8C,0xEE,0x1F};
 
@@ -620,9 +833,9 @@ uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot)
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast13;
-          xfer += iprot->readI32(ecast13);
-          this->grantorType = (PrincipalType::type)ecast13;
+          int32_t ecast21;
+          xfer += iprot->readI32(ecast21);
+          this->grantorType = (PrincipalType::type)ecast21;
           this->__isset.grantorType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -650,6 +863,7 @@ uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot)
 
 uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("PrivilegeGrantInfo");
 
   xfer += oprot->writeFieldBegin("privilege", ::apache::thrift::protocol::T_STRING, 1);
@@ -674,6 +888,7 @@ uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* oprot)
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -687,6 +902,56 @@ void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) {
   swap(a.__isset, b.__isset);
 }
 
+PrivilegeGrantInfo::PrivilegeGrantInfo(const PrivilegeGrantInfo& other22) {
+  privilege = other22.privilege;
+  createTime = other22.createTime;
+  grantor = other22.grantor;
+  grantorType = other22.grantorType;
+  grantOption = other22.grantOption;
+  __isset = other22.__isset;
+}
+PrivilegeGrantInfo& PrivilegeGrantInfo::operator=(const PrivilegeGrantInfo& other23) {
+  privilege = other23.privilege;
+  createTime = other23.createTime;
+  grantor = other23.grantor;
+  grantorType = other23.grantorType;
+  grantOption = other23.grantOption;
+  __isset = other23.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const PrivilegeGrantInfo& obj) {
+  using apache::thrift::to_string;
+  out << "PrivilegeGrantInfo(";
+  out << "privilege=" << to_string(obj.privilege);
+  out << ", " << "createTime=" << to_string(obj.createTime);
+  out << ", " << "grantor=" << to_string(obj.grantor);
+  out << ", " << "grantorType=" << to_string(obj.grantorType);
+  out << ", " << "grantOption=" << to_string(obj.grantOption);
+  out << ")";
+  return out;
+}
+
+
+HiveObjectPrivilege::~HiveObjectPrivilege() throw() {
+}
+
+
+void HiveObjectPrivilege::__set_hiveObject(const HiveObjectRef& val) {
+  this->hiveObject = val;
+}
+
+void HiveObjectPrivilege::__set_principalName(const std::string& val) {
+  this->principalName = val;
+}
+
+void HiveObjectPrivilege::__set_principalType(const PrincipalType::type val) {
+  this->principalType = val;
+}
+
+void HiveObjectPrivilege::__set_grantInfo(const PrivilegeGrantInfo& val) {
+  this->grantInfo = val;
+}
+
 const char* HiveObjectPrivilege::ascii_fingerprint = "83D71969B23BD853E29DBA9D43B29AF8";
 const uint8_t HiveObjectPrivilege::binary_fingerprint[16] = {0x83,0xD7,0x19,0x69,0xB2,0x3B,0xD8,0x53,0xE2,0x9D,0xBA,0x9D,0x43,0xB2,0x9A,0xF8};
 
@@ -728,9 +993,9 @@ uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot)
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast14;
-          xfer += iprot->readI32(ecast14);
-          this->principalType = (PrincipalType::type)ecast14;
+          int32_t ecast24;
+          xfer += iprot->readI32(ecast24);
+          this->principalType = (PrincipalType::type)ecast24;
           this->__isset.principalType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -758,6 +1023,7 @@ uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot)
 
 uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("HiveObjectPrivilege");
 
   xfer += oprot->writeFieldBegin("hiveObject", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -778,6 +1044,7 @@ uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* oprot
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -790,6 +1057,41 @@ void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) {
   swap(a.__isset, b.__isset);
 }
 
+HiveObjectPrivilege::HiveObjectPrivilege(const HiveObjectPrivilege& other25) {
+  hiveObject = other25.hiveObject;
+  principalName = other25.principalName;
+  principalType = other25.principalType;
+  grantInfo = other25.grantInfo;
+  __isset = other25.__isset;
+}
+HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& other26) {
+  hiveObject = other26.hiveObject;
+  principalName = other26.principalName;
+  principalType = other26.principalType;
+  grantInfo = other26.grantInfo;
+  __isset = other26.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const HiveObjectPrivilege& obj) {
+  using apache::thrift::to_string;
+  out << "HiveObjectPrivilege(";
+  out << "hiveObject=" << to_string(obj.hiveObject);
+  out << ", " << "principalName=" << to_string(obj.principalName);
+  out << ", " << "principalType=" << to_string(obj.principalType);
+  out << ", " << "grantInfo=" << to_string(obj.grantInfo);
+  out << ")";
+  return out;
+}
+
+
+PrivilegeBag::~PrivilegeBag() throw() {
+}
+
+
+void PrivilegeBag::__set_privileges(const std::vector<HiveObjectPrivilege> & val) {
+  this->privileges = val;
+}
+
 const char* PrivilegeBag::ascii_fingerprint = "BB89E4701B7B709B046A74C90B1147F2";
 const uint8_t PrivilegeBag::binary_fingerprint[16] = {0xBB,0x89,0xE4,0x70,0x1B,0x7B,0x70,0x9B,0x04,0x6A,0x74,0xC9,0x0B,0x11,0x47,0xF2};
 
@@ -817,14 +1119,14 @@ uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->privileges.clear();
-            uint32_t _size15;
-            ::apache::thrift::protocol::TType _etype18;
-            xfer += iprot->readListBegin(_etype18, _size15);
-            this->privileges.resize(_size15);
-            uint32_t _i19;
-            for (_i19 = 0; _i19 < _size15; ++_i19)
+            uint32_t _size27;
+            ::apache::thrift::protocol::TType _etype30;
+            xfer += iprot->readListBegin(_etype30, _size27);
+            this->privileges.resize(_size27);
+            uint32_t _i31;
+            for (_i31 = 0; _i31 < _size27; ++_i31)
             {
-              xfer += this->privileges[_i19].read(iprot);
+              xfer += this->privileges[_i31].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -847,15 +1149,16 @@ uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("PrivilegeBag");
 
   xfer += oprot->writeFieldBegin("privileges", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->privileges.size()));
-    std::vector<HiveObjectPrivilege> ::const_iterator _iter20;
-    for (_iter20 = this->privileges.begin(); _iter20 != this->privileges.end(); ++_iter20)
+    std::vector<HiveObjectPrivilege> ::const_iterator _iter32;
+    for (_iter32 = this->privileges.begin(); _iter32 != this->privileges.end(); ++_iter32)
     {
-      xfer += (*_iter20).write(oprot);
+      xfer += (*_iter32).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -863,6 +1166,7 @@ uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -872,6 +1176,40 @@ void swap(PrivilegeBag &a, PrivilegeBag &b) {
   swap(a.__isset, b.__isset);
 }
 
+PrivilegeBag::PrivilegeBag(const PrivilegeBag& other33) {
+  privileges = other33.privileges;
+  __isset = other33.__isset;
+}
+PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other34) {
+  privileges = other34.privileges;
+  __isset = other34.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const PrivilegeBag& obj) {
+  using apache::thrift::to_string;
+  out << "PrivilegeBag(";
+  out << "privileges=" << to_string(obj.privileges);
+  out << ")";
+  return out;
+}
+
+
+PrincipalPrivilegeSet::~PrincipalPrivilegeSet() throw() {
+}
+
+
+void PrincipalPrivilegeSet::__set_userPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val) {
+  this->userPrivileges = val;
+}
+
+void PrincipalPrivilegeSet::__set_groupPrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val) {
+  this->groupPrivileges = val;
+}
+
+void PrincipalPrivilegeSet::__set_rolePrivileges(const std::map<std::string, std::vector<PrivilegeGrantInfo> > & val) {
+  this->rolePrivileges = val;
+}
+
 const char* PrincipalPrivilegeSet::ascii_fingerprint = "08F75D2533906EA87BE34EA640856683";
 const uint8_t PrincipalPrivilegeSet::binary_fingerprint[16] = {0x08,0xF7,0x5D,0x25,0x33,0x90,0x6E,0xA8,0x7B,0xE3,0x4E,0xA6,0x40,0x85,0x66,0x83};
 
@@ -899,26 +1237,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->userPrivileges.clear();
-            uint32_t _size21;
-            ::apache::thrift::protocol::TType _ktype22;
-            ::apache::thrift::protocol::TType _vtype23;
-            xfer += iprot->readMapBegin(_ktype22, _vtype23, _size21);
-            uint32_t _i25;
-            for (_i25 = 0; _i25 < _size21; ++_i25)
+            uint32_t _size35;
+            ::apache::thrift::protocol::TType _ktype36;
+            ::apache::thrift::protocol::TType _vtype37;
+            xfer += iprot->readMapBegin(_ktype36, _vtype37, _size35);
+            uint32_t _i39;
+            for (_i39 = 0; _i39 < _size35; ++_i39)
             {
-              std::string _key26;
-              xfer += iprot->readString(_key26);
-              std::vector<PrivilegeGrantInfo> & _val27 = this->userPrivileges[_key26];
+              std::string _key40;
+              xfer += iprot->readString(_key40);
+              std::vector<PrivilegeGrantInfo> & _val41 = this->userPrivileges[_key40];
               {
-                _val27.clear();
-                uint32_t _size28;
-                ::apache::thrift::protocol::TType _etype31;
-                xfer += iprot->readListBegin(_etype31, _size28);
-                _val27.resize(_size28);
-                uint32_t _i32;
-                for (_i32 = 0; _i32 < _size28; ++_i32)
+                _val41.clear();
+                uint32_t _size42;
+                ::apache::thrift::protocol::TType _etype45;
+                xfer += iprot->readListBegin(_etype45, _size42);
+                _val41.resize(_size42);
+                uint32_t _i46;
+                for (_i46 = 0; _i46 < _size42; ++_i46)
                 {
-                  xfer += _val27[_i32].read(iprot);
+                  xfer += _val41[_i46].read(iprot);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -934,26 +1272,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->groupPrivileges.clear();
-            uint32_t _size33;
-            ::apache::thrift::protocol::TType _ktype34;
-            ::apache::thrift::protocol::TType _vtype35;
-            xfer += iprot->readMapBegin(_ktype34, _vtype35, _size33);
-            uint32_t _i37;
-            for (_i37 = 0; _i37 < _size33; ++_i37)
+            uint32_t _size47;
+            ::apache::thrift::protocol::TType _ktype48;
+            ::apache::thrift::protocol::TType _vtype49;
+            xfer += iprot->readMapBegin(_ktype48, _vtype49, _size47);
+            uint32_t _i51;
+            for (_i51 = 0; _i51 < _size47; ++_i51)
             {
-              std::string _key38;
-              xfer += iprot->readString(_key38);
-              std::vector<PrivilegeGrantInfo> & _val39 = this->groupPrivileges[_key38];
+              std::string _key52;
+              xfer += iprot->readString(_key52);
+              std::vector<PrivilegeGrantInfo> & _val53 = this->groupPrivileges[_key52];
               {
-                _val39.clear();
-                uint32_t _size40;
-                ::apache::thrift::protocol::TType _etype43;
-                xfer += iprot->readListBegin(_etype43, _size40);
-                _val39.resize(_size40);
-                uint32_t _i44;
-                for (_i44 = 0; _i44 < _size40; ++_i44)
+                _val53.clear();
+                uint32_t _size54;
+                ::apache::thrift::protocol::TType _etype57;
+                xfer += iprot->readListBegin(_etype57, _size54);
+                _val53.resize(_size54);
+                uint32_t _i58;
+                for (_i58 = 0; _i58 < _size54; ++_i58)
                 {
-                  xfer += _val39[_i44].read(iprot);
+                  xfer += _val53[_i58].read(iprot);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -969,26 +1307,26 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->rolePrivileges.clear();
-            uint32_t _size45;
-            ::apache::thrift::protocol::TType _ktype46;
-            ::apache::thrift::protocol::TType _vtype47;
-            xfer += iprot->readMapBegin(_ktype46, _vtype47, _size45);
-            uint32_t _i49;
-            for (_i49 = 0; _i49 < _size45; ++_i49)
+            uint32_t _size59;
+            ::apache::thrift::protocol::TType _ktype60;
+            ::apache::thrift::protocol::TType _vtype61;
+            xfer += iprot->readMapBegin(_ktype60, _vtype61, _size59);
+            uint32_t _i63;
+            for (_i63 = 0; _i63 < _size59; ++_i63)
             {
-              std::string _key50;
-              xfer += iprot->readString(_key50);
-              std::vector<PrivilegeGrantInfo> & _val51 = this->rolePrivileges[_key50];
+              std::string _key64;
+              xfer += iprot->readString(_key64);
+              std::vector<PrivilegeGrantInfo> & _val65 = this->rolePrivileges[_key64];
               {
-                _val51.clear();
-                uint32_t _size52;
-                ::apache::thrift::protocol::TType _etype55;
-                xfer += iprot->readListBegin(_etype55, _size52);
-                _val51.resize(_size52);
-                uint32_t _i56;
-                for (_i56 = 0; _i56 < _size52; ++_i56)
+                _val65.clear();
+                uint32_t _size66;
+                ::apache::thrift::protocol::TType _etype69;
+                xfer += iprot->readListBegin(_etype69, _size66);
+                _val65.resize(_size66);
+                uint32_t _i70;
+                for (_i70 = 0; _i70 < _size66; ++_i70)
                 {
-                  xfer += _val51[_i56].read(iprot);
+                  xfer += _val65[_i70].read(iprot);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -1014,21 +1352,22 @@ uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
 
 uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("PrincipalPrivilegeSet");
 
   xfer += oprot->writeFieldBegin("userPrivileges", ::apache::thrift::protocol::T_MAP, 1);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->userPrivileges.size()));
-    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter57;
-    for (_iter57 = this->userPrivileges.begin(); _iter57 != this->userPrivileges.end(); ++_iter57)
+    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter71;
+    for (_iter71 = this->userPrivileges.begin(); _iter71 != this->userPrivileges.end(); ++_iter71)
     {
-      xfer += oprot->writeString(_iter57->first);
+      xfer += oprot->writeString(_iter71->first);
       {
-        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter57->second.size()));
-        std::vector<PrivilegeGrantInfo> ::const_iterator _iter58;
-        for (_iter58 = _iter57->second.begin(); _iter58 != _iter57->second.end(); ++_iter58)
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter71->second.size()));
+        std::vector<PrivilegeGrantInfo> ::const_iterator _iter72;
+        for (_iter72 = _iter71->second.begin(); _iter72 != _iter71->second.end(); ++_iter72)
         {
-          xfer += (*_iter58).write(oprot);
+          xfer += (*_iter72).write(oprot);
         }
         xfer += oprot->writeListEnd();
       }
@@ -1040,16 +1379,16 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr
   xfer += oprot->writeFieldBegin("groupPrivileges", ::apache::thrift::protocol::T_MAP, 2);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->groupPrivileges.size()));
-    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter59;
-    for (_iter59 = this->groupPrivileges.begin(); _iter59 != this->groupPrivileges.end(); ++_iter59)
+    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter73;
+    for (_iter73 = this->groupPrivileges.begin(); _iter73 != this->groupPrivileges.end(); ++_iter73)
     {
-      xfer += oprot->writeString(_iter59->first);
+      xfer += oprot->writeString(_iter73->first);
       {
-        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter59->second.size()));
-        std::vector<PrivilegeGrantInfo> ::const_iterator _iter60;
-        for (_iter60 = _iter59->second.begin(); _iter60 != _iter59->second.end(); ++_iter60)
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter73->second.size()));
+        std::vector<PrivilegeGrantInfo> ::const_iterator _iter74;
+        for (_iter74 = _iter73->second.begin(); _iter74 != _iter73->second.end(); ++_iter74)
         {
-          xfer += (*_iter60).write(oprot);
+          xfer += (*_iter74).write(oprot);
         }
         xfer += oprot->writeListEnd();
       }
@@ -1061,16 +1400,16 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr
   xfer += oprot->writeFieldBegin("rolePrivileges", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->rolePrivileges.size()));
-    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter61;
-    for (_iter61 = this->rolePrivileges.begin(); _iter61 != this->rolePrivileges.end(); ++_iter61)
+    std::map<std::string, std::vector<PrivilegeGrantInfo> > ::const_iterator _iter75;
+    for (_iter75 = this->rolePrivileges.begin(); _iter75 != this->rolePrivileges.end(); ++_iter75)
     {
-      xfer += oprot->writeString(_iter61->first);
+      xfer += oprot->writeString(_iter75->first);
       {
-        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter61->second.size()));
-        std::vector<PrivilegeGrantInfo> ::const_iterator _iter62;
-        for (_iter62 = _iter61->second.begin(); _iter62 != _iter61->second.end(); ++_iter62)
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(_iter75->second.size()));
+        std::vector<PrivilegeGrantInfo> ::const_iterator _iter76;
+        for (_iter76 = _iter75->second.begin(); _iter76 != _iter75->second.end(); ++_iter76)
         {
-          xfer += (*_iter62).write(oprot);
+          xfer += (*_iter76).write(oprot);
         }
         xfer += oprot->writeListEnd();
       }
@@ -1081,6 +1420,7 @@ uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1092,6 +1432,47 @@ void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) {
   swap(a.__isset, b.__isset);
 }
 
+PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& other77) {
+  userPrivileges = other77.userPrivileges;
+  groupPrivileges = other77.groupPrivileges;
+  rolePrivileges = other77.rolePrivileges;
+  __isset = other77.__isset;
+}
+PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const PrincipalPrivilegeSet& other78) {
+  userPrivileges = other78.userPrivileges;
+  groupPrivileges = other78.groupPrivileges;
+  rolePrivileges = other78.rolePrivileges;
+  __isset = other78.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const PrincipalPrivilegeSet& obj) {
+  using apache::thrift::to_string;
+  out << "PrincipalPrivilegeSet(";
+  out << "userPrivileges=" << to_string(obj.userPrivileges);
+  out << ", " << "groupPrivileges=" << to_string(obj.groupPrivileges);
+  out << ", " << "rolePrivileges=" << to_string(obj.rolePrivileges);
+  out << ")";
+  return out;
+}
+
+
+GrantRevokePrivilegeRequest::~GrantRevokePrivilegeRequest() throw() {
+}
+
+
+void GrantRevokePrivilegeRequest::__set_requestType(const GrantRevokeType::type val) {
+  this->requestType = val;
+}
+
+void GrantRevokePrivilegeRequest::__set_privileges(const PrivilegeBag& val) {
+  this->privileges = val;
+}
+
+void GrantRevokePrivilegeRequest::__set_revokeGrantOption(const bool val) {
+  this->revokeGrantOption = val;
+__isset.revokeGrantOption = true;
+}
+
 const char* GrantRevokePrivilegeRequest::ascii_fingerprint = "DF474A3CB526AD40DC0F2C3702F7AA2C";
 const uint8_t GrantRevokePrivilegeRequest::binary_fingerprint[16] = {0xDF,0x47,0x4A,0x3C,0xB5,0x26,0xAD,0x40,0xDC,0x0F,0x2C,0x37,0x02,0xF7,0xAA,0x2C};
 
@@ -1117,9 +1498,9 @@ uint32_t GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast63;
-          xfer += iprot->readI32(ecast63);
-          this->requestType = (GrantRevokeType::type)ecast63;
+          int32_t ecast79;
+          xfer += iprot->readI32(ecast79);
+          this->requestType = (GrantRevokeType::type)ecast79;
           this->__isset.requestType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1155,6 +1536,7 @@ uint32_t GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol
 
 uint32_t GrantRevokePrivilegeRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GrantRevokePrivilegeRequest");
 
   xfer += oprot->writeFieldBegin("requestType", ::apache::thrift::protocol::T_I32, 1);
@@ -1172,6 +1554,7 @@ uint32_t GrantRevokePrivilegeRequest::write(::apache::thrift::protocol::TProtoco
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1183,6 +1566,39 @@ void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) {
   swap(a.__isset, b.__isset);
 }
 
+GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const GrantRevokePrivilegeRequest& other80) {
+  requestType = other80.requestType;
+  privileges = other80.privileges;
+  revokeGrantOption = other80.revokeGrantOption;
+  __isset = other80.__isset;
+}
+GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const GrantRevokePrivilegeRequest& other81) {
+  requestType = other81.requestType;
+  privileges = other81.privileges;
+  revokeGrantOption = other81.revokeGrantOption;
+  __isset = other81.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GrantRevokePrivilegeRequest(";
+  out << "requestType=" << to_string(obj.requestType);
+  out << ", " << "privileges=" << to_string(obj.privileges);
+  out << ", " << "revokeGrantOption="; (obj.__isset.revokeGrantOption ? (out << to_string(obj.revokeGrantOption)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+GrantRevokePrivilegeResponse::~GrantRevokePrivilegeResponse() throw() {
+}
+
+
+void GrantRevokePrivilegeResponse::__set_success(const bool val) {
+  this->success = val;
+__isset.success = true;
+}
+
 const char* GrantRevokePrivilegeResponse::ascii_fingerprint = "BF054652DEF86253C2BEE7D947F167DD";
 const uint8_t GrantRevokePrivilegeResponse::binary_fingerprint[16] = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
 
@@ -1228,6 +1644,7 @@ uint32_t GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtoco
 
 uint32_t GrantRevokePrivilegeResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GrantRevokePrivilegeResponse");
 
   if (this->__isset.success) {
@@ -1237,6 +1654,7 @@ uint32_t GrantRevokePrivilegeResponse::write(::apache::thrift::protocol::TProtoc
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1246,6 +1664,40 @@ void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) {
   swap(a.__isset, b.__isset);
 }
 
+GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const GrantRevokePrivilegeResponse& other82) {
+  success = other82.success;
+  __isset = other82.__isset;
+}
+GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const GrantRevokePrivilegeResponse& other83) {
+  success = other83.success;
+  __isset = other83.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GrantRevokePrivilegeResponse& obj) {
+  using apache::thrift::to_string;
+  out << "GrantRevokePrivilegeResponse(";
+  out << "success="; (obj.__isset.success ? (out << to_string(obj.success)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+Role::~Role() throw() {
+}
+
+
+void Role::__set_roleName(const std::string& val) {
+  this->roleName = val;
+}
+
+void Role::__set_createTime(const int32_t val) {
+  this->createTime = val;
+}
+
+void Role::__set_ownerName(const std::string& val) {
+  this->ownerName = val;
+}
+
 const char* Role::ascii_fingerprint = "70563A0628F75DF9555F4D24690B1E26";
 const uint8_t Role::binary_fingerprint[16] = {0x70,0x56,0x3A,0x06,0x28,0xF7,0x5D,0xF9,0x55,0x5F,0x4D,0x24,0x69,0x0B,0x1E,0x26};
 
@@ -1307,6 +1759,7 @@ uint32_t Role::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Role");
 
   xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1);
@@ -1323,6 +1776,7 @@ uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1334,6 +1788,62 @@ void swap(Role &a, Role &b) {
   swap(a.__isset, b.__isset);
 }
 
+Role::Role(const Role& other84) {
+  roleName = other84.roleName;
+  createTime = other84.createTime;
+  ownerName = other84.ownerName;
+  __isset = other84.__isset;
+}
+Role& Role::operator=(const Role& other85) {
+  roleName = other85.roleName;
+  createTime = other85.createTime;
+  ownerName = other85.ownerName;
+  __isset = other85.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Role& obj) {
+  using apache::thrift::to_string;
+  out << "Role(";
+  out << "roleName=" << to_string(obj.roleName);
+  out << ", " << "createTime=" << to_string(obj.createTime);
+  out << ", " << "ownerName=" << to_string(obj.ownerName);
+  out << ")";
+  return out;
+}
+
+
+RolePrincipalGrant::~RolePrincipalGrant() throw() {
+}
+
+
+void RolePrincipalGrant::__set_roleName(const std::string& val) {
+  this->roleName = val;
+}
+
+void RolePrincipalGrant::__set_principalName(const std::string& val) {
+  this->principalName = val;
+}
+
+void RolePrincipalGrant::__set_principalType(const PrincipalType::type val) {
+  this->principalType = val;
+}
+
+void RolePrincipalGrant::__set_grantOption(const bool val) {
+  this->grantOption = val;
+}
+
+void RolePrincipalGrant::__set_grantTime(const int32_t val) {
+  this->grantTime = val;
+}
+
+void RolePrincipalGrant::__set_grantorName(const std::string& val) {
+  this->grantorName = val;
+}
+
+void RolePrincipalGrant::__set_grantorPrincipalType(const PrincipalType::type val) {
+  this->grantorPrincipalType = val;
+}
+
 const char* RolePrincipalGrant::ascii_fingerprint = "899BA3F6214DD1B79D27206BA857C772";
 const uint8_t RolePrincipalGrant::binary_fingerprint[16] = {0x89,0x9B,0xA3,0xF6,0x21,0x4D,0xD1,0xB7,0x9D,0x27,0x20,0x6B,0xA8,0x57,0xC7,0x72};
 
@@ -1375,9 +1885,9 @@ uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot)
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast64;
-          xfer += iprot->readI32(ecast64);
-          this->principalType = (PrincipalType::type)ecast64;
+          int32_t ecast86;
+          xfer += iprot->readI32(ecast86);
+          this->principalType = (PrincipalType::type)ecast86;
           this->__isset.principalType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1409,9 +1919,9 @@ uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot)
         break;
       case 7:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast65;
-          xfer += iprot->readI32(ecast65);
-          this->grantorPrincipalType = (PrincipalType::type)ecast65;
+          int32_t ecast87;
+          xfer += iprot->readI32(ecast87);
+          this->grantorPrincipalType = (PrincipalType::type)ecast87;
           this->__isset.grantorPrincipalType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1431,6 +1941,7 @@ uint32_t RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot)
 
 uint32_t RolePrincipalGrant::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("RolePrincipalGrant");
 
   xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1);
@@ -1463,6 +1974,7 @@ uint32_t RolePrincipalGrant::write(::apache::thrift::protocol::TProtocol* oprot)
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1478,6 +1990,54 @@ void swap(RolePrincipalGrant &a, RolePrincipalGrant &b) {
   swap(a.__isset, b.__isset);
 }
 
+RolePrincipalGrant::RolePrincipalGrant(const RolePrincipalGrant& other88) {
+  roleName = other88.roleName;
+  principalName = other88.principalName;
+  principalType = other88.principalType;
+  grantOption = other88.grantOption;
+  grantTime = other88.grantTime;
+  grantorName = other88.grantorName;
+  grantorPrincipalType = other88.grantorPrincipalType;
+  __isset = other88.__isset;
+}
+RolePrincipalGrant& RolePrincipalGrant::operator=(const RolePrincipalGrant& other89) {
+  roleName = other89.roleName;
+  principalName = other89.principalName;
+  principalType = other89.principalType;
+  grantOption = other89.grantOption;
+  grantTime = other89.grantTime;
+  grantorName = other89.grantorName;
+  grantorPrincipalType = other89.grantorPrincipalType;
+  __isset = other89.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const RolePrincipalGrant& obj) {
+  using apache::thrift::to_string;
+  out << "RolePrincipalGrant(";
+  out << "roleName=" << to_string(obj.roleName);
+  out << ", " << "principalName=" << to_string(obj.principalName);
+  out << ", " << "principalType=" << to_string(obj.principalType);
+  out << ", " << "grantOption=" << to_string(obj.grantOption);
+  out << ", " << "grantTime=" << to_string(obj.grantTime);
+  out << ", " << "grantorName=" << to_string(obj.grantorName);
+  out << ", " << "grantorPrincipalType=" << to_string(obj.grantorPrincipalType);
+  out << ")";
+  return out;
+}
+
+
+GetRoleGrantsForPrincipalRequest::~GetRoleGrantsForPrincipalRequest() throw() {
+}
+
+
+void GetRoleGrantsForPrincipalRequest::__set_principal_name(const std::string& val) {
+  this->principal_name = val;
+}
+
+void GetRoleGrantsForPrincipalRequest::__set_principal_type(const PrincipalType::type val) {
+  this->principal_type = val;
+}
+
 const char* GetRoleGrantsForPrincipalRequest::ascii_fingerprint = "D6FD826D949221396F4FFC3ECCD3D192";
 const uint8_t GetRoleGrantsForPrincipalRequest::binary_fingerprint[16] = {0xD6,0xFD,0x82,0x6D,0x94,0x92,0x21,0x39,0x6F,0x4F,0xFC,0x3E,0xCC,0xD3,0xD1,0x92};
 
@@ -1513,9 +2073,9 @@ uint32_t GetRoleGrantsForPrincipalRequest::read(::apache::thrift::protocol::TPro
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast66;
-          xfer += iprot->readI32(ecast66);
-          this->principal_type = (PrincipalType::type)ecast66;
+          int32_t ecast90;
+          xfer += iprot->readI32(ecast90);
+          this->principal_type = (PrincipalType::type)ecast90;
           isset_principal_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1539,6 +2099,7 @@ uint32_t GetRoleGrantsForPrincipalRequest::read(::apache::thrift::protocol::TPro
 
 uint32_t GetRoleGrantsForPrincipalRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GetRoleGrantsForPrincipalRequest");
 
   xfer += oprot->writeFieldBegin("principal_name", ::apache::thrift::protocol::T_STRING, 1);
@@ -1551,6 +2112,7 @@ uint32_t GetRoleGrantsForPrincipalRequest::write(::apache::thrift::protocol::TPr
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1560,6 +2122,33 @@ void swap(GetRoleGrantsForPrincipalRequest &a, GetRoleGrantsForPrincipalRequest
   swap(a.principal_type, b.principal_type);
 }
 
+GetRoleGrantsForPrincipalRequest::GetRoleGrantsForPrincipalRequest(const GetRoleGrantsForPrincipalRequest& other91) {
+  principal_name = other91.principal_name;
+  principal_type = other91.principal_type;
+}
+GetRoleGrantsForPrincipalRequest& GetRoleGrantsForPrincipalRequest::operator=(const GetRoleGrantsForPrincipalRequest& other92) {
+  principal_name = other92.principal_name;
+  principal_type = other92.principal_type;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GetRoleGrantsForPrincipalRequest(";
+  out << "principal_name=" << to_string(obj.principal_name);
+  out << ", " << "principal_type=" << to_string(obj.principal_type);
+  out << ")";
+  return out;
+}
+
+
+GetRoleGrantsForPrincipalResponse::~GetRoleGrantsForPrincipalResponse() throw() {
+}
+
+
+void GetRoleGrantsForPrincipalResponse::__set_principalGrants(const std::vector<RolePrincipalGrant> & val) {
+  this->principalGrants = val;
+}
+
 const char* GetRoleGrantsForPrincipalResponse::ascii_fingerprint = "5926B4B3541A62E17663820C7E3BE690";
 const uint8_t GetRoleGrantsForPrincipalResponse::binary_fingerprint[16] = {0x59,0x26,0xB4,0xB3,0x54,0x1A,0x62,0xE1,0x76,0x63,0x82,0x0C,0x7E,0x3B,0xE6,0x90};
 
@@ -1588,14 +2177,14 @@ uint32_t GetRoleGrantsForPrincipalResponse::read(::apache::thrift::protocol::TPr
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->principalGrants.clear();
-            uint32_t _size67;
-            ::apache::thrift::protocol::TType _etype70;
-            xfer += iprot->readListBegin(_etype70, _size67);
-            this->principalGrants.resize(_size67);
-            uint32_t _i71;
-            for (_i71 = 0; _i71 < _size67; ++_i71)
+            uint32_t _size93;
+            ::apache::thrift::protocol::TType _etype96;
+            xfer += iprot->readListBegin(_etype96, _size93);
+            this->principalGrants.resize(_size93);
+            uint32_t _i97;
+            for (_i97 = 0; _i97 < _size93; ++_i97)
             {
-              xfer += this->principalGrants[_i71].read(iprot);
+              xfer += this->principalGrants[_i97].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1620,15 +2209,16 @@ uint32_t GetRoleGrantsForPrincipalResponse::read(::apache::thrift::protocol::TPr
 
 uint32_t GetRoleGrantsForPrincipalResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GetRoleGrantsForPrincipalResponse");
 
   xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->principalGrants.size()));
-    std::vector<RolePrincipalGrant> ::const_iterator _iter72;
-    for (_iter72 = this->principalGrants.begin(); _iter72 != this->principalGrants.end(); ++_iter72)
+    std::vector<RolePrincipalGrant> ::const_iterator _iter98;
+    for (_iter98 = this->principalGrants.begin(); _iter98 != this->principalGrants.end(); ++_iter98)
     {
-      xfer += (*_iter72).write(oprot);
+      xfer += (*_iter98).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1636,6 +2226,7 @@ uint32_t GetRoleGrantsForPrincipalResponse::write(::apache::thrift::protocol::TP
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1644,6 +2235,30 @@ void swap(GetRoleGrantsForPrincipalResponse &a, GetRoleGrantsForPrincipalRespons
   swap(a.principalGrants, b.principalGrants);
 }
 
+GetRoleGrantsForPrincipalResponse::GetRoleGrantsForPrincipalResponse(const GetRoleGrantsForPrincipalResponse& other99) {
+  principalGrants = other99.principalGrants;
+}
+GetRoleGrantsForPrincipalResponse& GetRoleGrantsForPrincipalResponse::operator=(const GetRoleGrantsForPrincipalResponse& other100) {
+  principalGrants = other100.principalGrants;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetRoleGrantsForPrincipalResponse& obj) {
+  using apache::thrift::to_string;
+  out << "GetRoleGrantsForPrincipalResponse(";
+  out << "principalGrants=" << to_string(obj.principalGrants);
+  out << ")";
+  return out;
+}
+
+
+GetPrincipalsInRoleRequest::~GetPrincipalsInRoleRequest() throw() {
+}
+
+
+void GetPrincipalsInRoleRequest::__set_roleName(const std::string& val) {
+  this->roleName = val;
+}
+
 const char* GetPrincipalsInRoleRequest::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
 const uint8_t GetPrincipalsInRoleRequest::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 
@@ -1692,6 +2307,7 @@ uint32_t GetPrincipalsInRoleRequest::read(::apache::thrift::protocol::TProtocol*
 
 uint32_t GetPrincipalsInRoleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GetPrincipalsInRoleRequest");
 
   xfer += oprot->writeFieldBegin("roleName", ::apache::thrift::protocol::T_STRING, 1);
@@ -1700,6 +2316,7 @@ uint32_t GetPrincipalsInRoleRequest::write(::apache::thrift::protocol::TProtocol
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1708,6 +2325,30 @@ void swap(GetPrincipalsInRoleRequest &a, GetPrincipalsInRoleRequest &b) {
   swap(a.roleName, b.roleName);
 }
 
+GetPrincipalsInRoleRequest::GetPrincipalsInRoleRequest(const GetPrincipalsInRoleRequest& other101) {
+  roleName = other101.roleName;
+}
+GetPrincipalsInRoleRequest& GetPrincipalsInRoleRequest::operator=(const GetPrincipalsInRoleRequest& other102) {
+  roleName = other102.roleName;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GetPrincipalsInRoleRequest(";
+  out << "roleName=" << to_string(obj.roleName);
+  out << ")";
+  return out;
+}
+
+
+GetPrincipalsInRoleResponse::~GetPrincipalsInRoleResponse() throw() {
+}
+
+
+void GetPrincipalsInRoleResponse::__set_principalGrants(const std::vector<RolePrincipalGrant> & val) {
+  this->principalGrants = val;
+}
+
 const char* GetPrincipalsInRoleResponse::ascii_fingerprint = "5926B4B3541A62E17663820C7E3BE690";
 const uint8_t GetPrincipalsInRoleResponse::binary_fingerprint[16] = {0x59,0x26,0xB4,0xB3,0x54,0x1A,0x62,0xE1,0x76,0x63,0x82,0x0C,0x7E,0x3B,0xE6,0x90};
 
@@ -1736,14 +2377,14 @@ uint32_t GetPrincipalsInRoleResponse::read(::apache::thrift::protocol::TProtocol
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->principalGrants.clear();
-            uint32_t _size73;
-            ::apache::thrift::protocol::TType _etype76;
-            xfer += iprot->readListBegin(_etype76, _size73);
-            this->principalGrants.resize(_size73);
-            uint32_t _i77;
-            for (_i77 = 0; _i77 < _size73; ++_i77)
+            uint32_t _size103;
+            ::apache::thrift::protocol::TType _etype106;
+            xfer += iprot->readListBegin(_etype106, _size103);
+            this->principalGrants.resize(_size103);
+            uint32_t _i107;
+            for (_i107 = 0; _i107 < _size103; ++_i107)
             {
-              xfer += this->principalGrants[_i77].read(iprot);
+              xfer += this->principalGrants[_i107].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -1768,15 +2409,16 @@ uint32_t GetPrincipalsInRoleResponse::read(::apache::thrift::protocol::TProtocol
 
 uint32_t GetPrincipalsInRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GetPrincipalsInRoleResponse");
 
   xfer += oprot->writeFieldBegin("principalGrants", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->principalGrants.size()));
-    std::vector<RolePrincipalGrant> ::const_iterator _iter78;
-    for (_iter78 = this->principalGrants.begin(); _iter78 != this->principalGrants.end(); ++_iter78)
+    std::vector<RolePrincipalGrant> ::const_iterator _iter108;
+    for (_iter108 = this->principalGrants.begin(); _iter108 != this->principalGrants.end(); ++_iter108)
     {
-      xfer += (*_iter78).write(oprot);
+      xfer += (*_iter108).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -1784,6 +2426,7 @@ uint32_t GetPrincipalsInRoleResponse::write(::apache::thrift::protocol::TProtoco
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1792,6 +2435,57 @@ void swap(GetPrincipalsInRoleResponse &a, GetPrincipalsInRoleResponse &b) {
   swap(a.principalGrants, b.principalGrants);
 }
 
+GetPrincipalsInRoleResponse::GetPrincipalsInRoleResponse(const GetPrincipalsInRoleResponse& other109) {
+  principalGrants = other109.principalGrants;
+}
+GetPrincipalsInRoleResponse& GetPrincipalsInRoleResponse::operator=(const GetPrincipalsInRoleResponse& other110) {
+  principalGrants = other110.principalGrants;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GetPrincipalsInRoleResponse& obj) {
+  using apache::thrift::to_string;
+  out << "GetPrincipalsInRoleResponse(";
+  out << "principalGrants=" << to_string(obj.principalGrants);
+  out << ")";
+  return out;
+}
+
+
+GrantRevokeRoleRequest::~GrantRevokeRoleRequest() throw() {
+}
+
+
+void GrantRevokeRoleRequest::__set_requestType(const GrantRevokeType::type val) {
+  this->requestType = val;
+}
+
+void GrantRevokeRoleRequest::__set_roleName(const std::string& val) {
+  this->roleName = val;
+}
+
+void GrantRevokeRoleRequest::__set_principalName(const std::string& val) {
+  this->principalName = val;
+}
+
+void GrantRevokeRoleRequest::__set_principalType(const PrincipalType::type val) {
+  this->principalType = val;
+}
+
+void GrantRevokeRoleRequest::__set_grantor(const std::string& val) {
+  this->grantor = val;
+__isset.grantor = true;
+}
+
+void GrantRevokeRoleRequest::__set_grantorType(const PrincipalType::type val) {
+  this->grantorType = val;
+__isset.grantorType = true;
+}
+
+void GrantRevokeRoleRequest::__set_grantOption(const bool val) {
+  this->grantOption = val;
+__isset.grantOption = true;
+}
+
 const char* GrantRevokeRoleRequest::ascii_fingerprint = "907DEA796F2BA7AF76DC2566E75FAEE7";
 const uint8_t GrantRevokeRoleRequest::binary_fingerprint[16] = {0x90,0x7D,0xEA,0x79,0x6F,0x2B,0xA7,0xAF,0x76,0xDC,0x25,0x66,0xE7,0x5F,0xAE,0xE7};
 
@@ -1817,9 +2511,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast79;
-          xfer += iprot->readI32(ecast79);
-          this->requestType = (GrantRevokeType::type)ecast79;
+          int32_t ecast111;
+          xfer += iprot->readI32(ecast111);
+          this->requestType = (GrantRevokeType::type)ecast111;
           this->__isset.requestType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1843,9 +2537,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast80;
-          xfer += iprot->readI32(ecast80);
-          this->principalType = (PrincipalType::type)ecast80;
+          int32_t ecast112;
+          xfer += iprot->readI32(ecast112);
+          this->principalType = (PrincipalType::type)ecast112;
           this->__isset.principalType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1861,9 +2555,9 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast81;
-          xfer += iprot->readI32(ecast81);
-          this->grantorType = (PrincipalType::type)ecast81;
+          int32_t ecast113;
+          xfer += iprot->readI32(ecast113);
+          this->grantorType = (PrincipalType::type)ecast113;
           this->__isset.grantorType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -1891,6 +2585,7 @@ uint32_t GrantRevokeRoleRequest::read(::apache::thrift::protocol::TProtocol* ipr
 
 uint32_t GrantRevokeRoleRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GrantRevokeRoleRequest");
 
   xfer += oprot->writeFieldBegin("requestType", ::apache::thrift::protocol::T_I32, 1);
@@ -1926,6 +2621,7 @@ uint32_t GrantRevokeRoleRequest::write(::apache::thrift::protocol::TProtocol* op
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -1941,6 +2637,51 @@ void swap(GrantRevokeRoleRequest &a, GrantRevokeRoleRequest &b) {
   swap(a.__isset, b.__isset);
 }
 
+GrantRevokeRoleRequest::GrantRevokeRoleRequest(const GrantRevokeRoleRequest& other114) {
+  requestType = other114.requestType;
+  roleName = other114.roleName;
+  principalName = other114.principalName;
+  principalType = other114.principalType;
+  grantor = other114.grantor;
+  grantorType = other114.grantorType;
+  grantOption = other114.grantOption;
+  __isset = other114.__isset;
+}
+GrantRevokeRoleRequest& GrantRevokeRoleRequest::operator=(const GrantRevokeRoleRequest& other115) {
+  requestType = other115.requestType;
+  roleName = other115.roleName;
+  principalName = other115.principalName;
+  principalType = other115.principalType;
+  grantor = other115.grantor;
+  grantorType = other115.grantorType;
+  grantOption = other115.grantOption;
+  __isset = other115.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleRequest& obj) {
+  using apache::thrift::to_string;
+  out << "GrantRevokeRoleRequest(";
+  out << "requestType=" << to_string(obj.requestType);
+  out << ", " << "roleName=" << to_string(obj.roleName);
+  out << ", " << "principalName=" << to_string(obj.principalName);
+  out << ", " << "principalType=" << to_string(obj.principalType);
+  out << ", " << "grantor="; (obj.__isset.grantor ? (out << to_string(obj.grantor)) : (out << "<null>"));
+  out << ", " << "grantorType="; (obj.__isset.grantorType ? (out << to_string(obj.grantorType)) : (out << "<null>"));
+  out << ", " << "grantOption="; (obj.__isset.grantOption ? (out << to_string(obj.grantOption)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+GrantRevokeRoleResponse::~GrantRevokeRoleResponse() throw() {
+}
+
+
+void GrantRevokeRoleResponse::__set_success(const bool val) {
+  this->success = val;
+__isset.success = true;
+}
+
 const char* GrantRevokeRoleResponse::ascii_fingerprint = "BF054652DEF86253C2BEE7D947F167DD";
 const uint8_t GrantRevokeRoleResponse::binary_fingerprint[16] = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD};
 
@@ -1986,6 +2727,7 @@ uint32_t GrantRevokeRoleResponse::read(::apache::thrift::protocol::TProtocol* ip
 
 uint32_t GrantRevokeRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("GrantRevokeRoleResponse");
 
   if (this->__isset.success) {
@@ -1995,6 +2737,7 @@ uint32_t GrantRevokeRoleResponse::write(::apache::thrift::protocol::TProtocol* o
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -2004,7 +2747,60 @@ void swap(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) {
   swap(a.__isset, b.__isset);
 }
 
-const char* Database::ascii_fingerprint = "553495CAE243A1C583D5C3DD990AED53";
+GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other116) {
+  success = other116.success;
+  __isset = other116.__isset;
+}
+GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other117) {
+  success = other117.success;
+  __isset = other117.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const GrantRevokeRoleResponse& obj) {
+  using apache::thrift::to_string;
+  out << "GrantRevokeRoleResponse(";
+  out << "success="; (obj.__isset.success ? (out << to_string(obj.success)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+Database::~Database() throw() {
+}
+
+
+void Database::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void Database::__set_description(const std::string& val) {
+  this->description = val;
+}
+
+void Database::__set_locationUri(const std::string& val) {
+  this->locationUri = val;
+}
+
+void Database::__set_parameters(const std::map<std::string, std::string> & val) {
+  this->parameters = val;
+}
+
+void Database::__set_privileges(const PrincipalPrivilegeSet& val) {
+  this->privileges = val;
+__isset.privileges = true;
+}
+
+void Database::__set_ownerName(const std::string& val) {
+  this->ownerName = val;
+__isset.ownerName = true;
+}
+
+void Database::__set_ownerType(const PrincipalType::type val) {
+  this->ownerType = val;
+__isset.ownerType = true;
+}
+
+const char* Database::ascii_fingerprint = "553495CAE243A1C583D5C3DD990AED53";
 const uint8_t Database::binary_fingerprint[16] = {0x55,0x34,0x95,0xCA,0xE2,0x43,0xA1,0xC5,0x83,0xD5,0xC3,0xDD,0x99,0x0A,0xED,0x53};
 
 uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
@@ -2055,17 +2851,17 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->parameters.clear();
-            uint32_t _size82;
-            ::apache::thrift::protocol::TType _ktype83;
-            ::apache::thrift::protocol::TType _vtype84;
-            xfer += iprot->readMapBegin(_ktype83, _vtype84, _size82);
-            uint32_t _i86;
-            for (_i86 = 0; _i86 < _size82; ++_i86)
+            uint32_t _size118;
+            ::apache::thrift::protocol::TType _ktype119;
+            ::apache::thrift::protocol::TType _vtype120;
+            xfer += iprot->readMapBegin(_ktype119, _vtype120, _size118);
+            uint32_t _i122;
+            for (_i122 = 0; _i122 < _size118; ++_i122)
             {
-              std::string _key87;
-              xfer += iprot->readString(_key87);
-              std::string& _val88 = this->parameters[_key87];
-              xfer += iprot->readString(_val88);
+              std::string _key123;
+              xfer += iprot->readString(_key123);
+              std::string& _val124 = this->parameters[_key123];
+              xfer += iprot->readString(_val124);
             }
             xfer += iprot->readMapEnd();
           }
@@ -2092,9 +2888,9 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 7:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast89;
-          xfer += iprot->readI32(ecast89);
-          this->ownerType = (PrincipalType::type)ecast89;
+          int32_t ecast125;
+          xfer += iprot->readI32(ecast125);
+          this->ownerType = (PrincipalType::type)ecast125;
           this->__isset.ownerType = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2114,6 +2910,7 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Database");
 
   xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
@@ -2131,11 +2928,11 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4);
   {
     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 _iter90;
-    for (_iter90 = this->parameters.begin(); _iter90 != this->parameters.end(); ++_iter90)
+    std::map<std::string, std::string> ::const_iterator _iter126;
+    for (_iter126 = this->parameters.begin(); _iter126 != this->parameters.end(); ++_iter126)
     {
-      xfer += oprot->writeString(_iter90->first);
-      xfer += oprot->writeString(_iter90->second);
+      xfer += oprot->writeString(_iter126->first);
+      xfer += oprot->writeString(_iter126->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -2158,6 +2955,7 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const {
   }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -2173,6 +2971,58 @@ void swap(Database &a, Database &b) {
   swap(a.__isset, b.__isset);
 }
 
+Database::Database(const Database& other127) {
+  name = other127.name;
+  description = other127.description;
+  locationUri = other127.locationUri;
+  parameters = other127.parameters;
+  privileges = other127.privileges;
+  ownerName = other127.ownerName;
+  ownerType = other127.ownerType;
+  __isset = other127.__isset;
+}
+Database& Database::operator=(const Database& other128) {
+  name = other128.name;
+  description = other128.description;
+  locationUri = other128.locationUri;
+  parameters = other128.parameters;
+  privileges = other128.privileges;
+  ownerName = other128.ownerName;
+  ownerType = other128.ownerType;
+  __isset = other128.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Database& obj) {
+  using apache::thrift::to_string;
+  out << "Database(";
+  out << "name=" << to_string(obj.name);
+  out << ", " << "description=" << to_string(obj.description);
+  out << ", " << "locationUri=" << to_string(obj.locationUri);
+  out << ", " << "parameters=" << to_string(obj.parameters);
+  out << ", " << "privileges="; (obj.__isset.privileges ? (out << to_string(obj.privileges)) : (out << "<null>"));
+  out << ", " << "ownerName="; (obj.__isset.ownerName ? (out << to_string(obj.ownerName)) : (out << "<null>"));
+  out << ", " << "ownerType="; (obj.__isset.ownerType ? (out << to_string(obj.ownerType)) : (out << "<null>"));
+  out << ")";
+  return out;
+}
+
+
+SerDeInfo::~SerDeInfo() throw() {
+}
+
+
+void SerDeInfo::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void SerDeInfo::__set_serializationLib(const std::string& val) {
+  this->serializationLib = val;
+}
+
+void SerDeInfo::__set_parameters(const std::map<std::string, std::string> & val) {
+  this->parameters = val;
+}
+
 const char* SerDeInfo::ascii_fingerprint = "B1021C32A35A2AEFCD2F57A5424159A7";
 const uint8_t SerDeInfo::binary_fingerprint[16] = {0xB1,0x02,0x1C,0x32,0xA3,0x5A,0x2A,0xEF,0xCD,0x2F,0x57,0xA5,0x42,0x41,0x59,0xA7};
 
@@ -2216,17 +3066,17 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->parameters.clear();
-            uint32_t _size91;
-            ::apache::thrift::protocol::TType _ktype92;
-            ::apache::thrift::protocol::TType _vtype93;
-            xfer += iprot->readMapBegin(_ktype92, _vtype93, _size91);
-            uint32_t _i95;
-            for (_i95 = 0; _i95 < _size91; ++_i95)
+            uint32_t _size129;
+            ::apache::thrift::protocol::TType _ktype130;
+            ::apache::thrift::protocol::TType _vtype131;
+            xfer += iprot->readMapBegin(_ktype130, _vtype131, _size129);
+            uint32_t _i133;
+            for (_i133 = 0; _i133 < _size129; ++_i133)
             {
-              std::string _key96;
-              xfer += iprot->readString(_key96);
-              std::string& _val97 = this->parameters[_key96];
-              xfer += iprot->readString(_val97);
+              std::string _key134;
+              xfer += iprot->readString(_key134);
+              std::string& _val135 = this->parameters[_key134];
+              xfer += iprot->readString(_val135);
             }
             xfer += iprot->readMapEnd();
           }
@@ -2249,6 +3099,7 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("SerDeInfo");
 
   xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
@@ -2262,11 +3113,11 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3);
   {
     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 _iter98;
-    for (_iter98 = this->parameters.begin(); _iter98 != this->parameters.end(); ++_iter98)
+    std::map<std::string, std::string> ::const_iterator _iter136;
+    for (_iter136 = this->parameters.begin(); _iter136 != this->parameters.end(); ++_iter136)
     {
-      xfer += oprot->writeString(_iter98->first);
-      xfer += oprot->writeString(_iter98->second);
+      xfer += oprot->writeString(_iter136->first);
+      xfer += oprot->writeString(_iter136->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -2274,6 +3125,7 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -2285,6 +3137,42 @@ void swap(SerDeInfo &a, SerDeInfo &b) {
   swap(a.__isset, b.__isset);
 }
 
+SerDeInfo::SerDeInfo(const SerDeInfo& other137) {
+  name = other137.name;
+  serializationLib = other137.serializationLib;
+  parameters = other137.parameters;
+  __isset = other137.__isset;
+}
+SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other138) {
+  name = other138.name;
+  serializationLib = other138.serializationLib;
+  parameters = other138.parameters;
+  __isset = other138.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const SerDeInfo& obj) {
+  using apache::thrift::to_string;
+  out << "SerDeInfo(";
+  out << "name=" << to_string(obj.name);
+  out << ", " << "serializationLib=" << to_string(obj.serializationLib);
+  out << ", " << "parameters=" << to_string(obj.parameters);
+  out << ")";
+  return out;
+}
+
+
+Order::~Order() throw() {
+}
+
+
+void Order::__set_col(const std::string& val) {
+  this->col = val;
+}
+
+void Order::__set_order(const int32_t val) {
+  this->order = val;
+}
+
 const char* Order::ascii_fingerprint = "EEBC915CE44901401D881E6091423036";
 const uint8_t Order::binary_fingerprint[16] = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
 
@@ -2338,6 +3226,7 @@ uint32_t Order::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t Order::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("Order");
 
   xfer += oprot->writeFieldBegin("col", ::apache::thrift::protocol::T_STRING, 1);
@@ -2350,6 +3239,7 @@ uint32_t Order::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -2360,6 +3250,43 @@ void swap(Order &a, Order &b) {
   swap(a.__isset, b.__isset);
 }
 
+Order::Order(const Order& other139) {
+  col = other139.col;
+  order = other139.order;
+  __isset = other139.__isset;
+}
+Order& Order::operator=(const Order& other140) {
+  col = other140.col;
+  order = other140.order;
+  __isset = other140.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const Order& obj) {
+  using apache::thrift::to_string;
+  out << "Order(";
+  out << "col=" << to_string(obj.col);
+  out << ", " << "order=" << to_string(obj.order);
+  out << ")";
+  return out;
+}
+
+
+SkewedInfo::~SkewedInfo() throw() {
+}
+
+
+void SkewedInfo::__set_skewedColNames(const std::vector<std::string> & val) {
+  this->skewedColNames = val;
+}
+
+void SkewedInfo::__set_skewedColValues(const std::vector<std::vector<std::string> > & val) {
+  this->skewedColValues = val;
+}
+
+void SkewedInfo::__set_skewedColValueLocationMaps(const std::map<std::vector<std::string> , std::string> & val) {
+  this->skewedColValueLocationMaps = val;
+}
+
 const char* SkewedInfo::ascii_fingerprint = "4BF2ED84BC3C3EB297A2AE2FA8427EB1";
 const uint8_t SkewedInfo::binary_fingerprint[16] = {0x4B,0xF2,0xED,0x84,0xBC,0x3C,0x3E,0xB2,0x97,0xA2,0xAE,0x2F,0xA8,0x42,0x7E,0xB1};
 
@@ -2387,14 +3314,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->skewedColNames.clear();
-            uint32_t _size99;
-            ::apache::thrift::protocol::TType _etype102;
-            xfer += iprot->readListBegin(_etype102, _size99);
-            this->skewedColNames.resize(_size99);
-            uint32_t _i103;
-            for (_i103 = 0; _i103 < _size99; ++_i103)
+            uint32_t _size141;
+            ::apache::thrift::protocol::TType _etype144;
+            xfer += iprot->readListBegin(_etype144, _size141);
+            this->skewedColNames.resize(_size141);
+            uint32_t _i145;
+            for (_i145 = 0; _i145 < _size141; ++_i145)
             {
-              xfer += iprot->readString(this->skewedColNames[_i103]);
+              xfer += iprot->readString(this->skewedColNames[_i145]);
             }
             xfer += iprot->readListEnd();
           }
@@ -2407,23 +3334,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->skewedColValues.clear();
-            uint32_t _size104;
-            ::apache::thrift::protocol::TType _etype107;
-            xfer += iprot->readListBegin(_etype107, _size104);
-            this->skewedColValues.resize(_size104);
-            uint32_t _i108;
-            for (_i108 = 0; _i108 < _size104; ++_i108)
+            uint32_t _size146;
+            ::apache::thrift::protocol::TType _etype149;
+            xfer += iprot->readListBegin(_etype149, _size146);
+            this->skewedColValues.resize(_size146);
+            uint32_t _i150;
+            for (_i150 = 0; _i150 < _size146; ++_i150)
             {
               {
-                this->skewedColValues[_i108].clear();
-                uint32_t _size109;
-                ::apache::thrift::protocol::TType _etype112;
-                xfer += iprot->readListBegin(_etype112, _size109);
-                this->skewedColValues[_i108].resize(_size109);
-                uint32_t _i113;
-                for (_i113 = 0; _i113 < _size109; ++_i113)
+                this->skewedColValues[_i150].clear();
+                uint32_t _size151;
+                ::apache::thrift::protocol::TType _etype154;
+                xfer += iprot->readListBegin(_etype154, _size151);
+                this->skewedColValues[_i150].resize(_size151);
+                uint32_t _i155;
+                for (_i155 = 0; _i155 < _size151; ++_i155)
                 {
-                  xfer += iprot->readString(this->skewedColValues[_i108][_i113]);
+                  xfer += iprot->readString(this->skewedColValues[_i150][_i155]);
                 }
                 xfer += iprot->readListEnd();
               }
@@ -2439,29 +3366,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_MAP) {
           {
             this->skewedColValueLocationMaps.clear();
-            uint32_t _size114;
-            ::apache::thrift::protocol::TType _ktype115;
-            ::apache::thrift::protocol::TType _vtype116;
-            xfer += iprot->readMapBegin(_ktype115, _vtype116, _size114);
-            uint32_t _i118;
-            for (_i118 = 0; _i118 < _size114; ++_i118)
+            uint32_t _size156;
+            ::apache::thrift::protocol::TType _ktype157;
+            ::apache::thrift::protocol::TType _vtype158;
+            xfer += iprot->readMapBegin(_ktype157, _vtype158, _size156);
+            uint32_t _i160;
+            for (_i160 = 0; _i160 < _size156; ++_i160)
             {
-              std::vector<std::string>  _key119;
+              std::vector<std::string>  _key161;
               {
-                _key119.clear();
-                uint32_t _size121;
-                ::apache::thrift::protocol::TType _etype124;
-                xfer += iprot->readListBegin(_etype124, _size121);
-                _key119.resize(_size121);
-                uint32_t _i125;
-                for (_i125 = 0; _i125 < _size121; ++_i125)
+                _key161.clear();
+                uint32_t _size163;
+                ::apache::thrift::protocol::TType _etype166;
+                xfer += iprot->readListBegin(_etype166, _size163);
+                _key161.resize(_size163);
+                uint32_t _i167;
+                for (_i167 = 0; _i167 < _size163; ++_i167)
                 {
-                  xfer += iprot->readString(_key119[_i125]);
+                  xfer += iprot->readString(_key161[_i167]);
                 }
                 xfer += iprot->readListEnd();
               }
-              std::string& _val120 = this->skewedColValueLocationMaps[_key119];
-              xfer += iprot->readString(_val120);
+              std::string& _val162 = this->skewedColValueLocationMaps[_key161];
+              xfer += iprot->readString(_val162);
             }
             xfer += iprot->readMapEnd();
           }
@@ -2484,15 +3411,16 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
 
 uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
+  oprot->incrementRecursionDepth();
   xfer += oprot->writeStructBegin("SkewedInfo");
 
   xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColNames.size()));
-    std::vector<std::string> ::const_iterator _iter126;
-    for (_iter126 = this->skewedColNames.begin(); _iter126 != this->skewedColNames.end(); ++_iter126)
+    std::vector<std::string> ::const_iterator _iter168;
+    for (_iter168 = this->skewedColNames.begin(); _iter168 != this->skewedColNames.end(); ++_iter168)
     {
-      xfer += oprot->writeString((*_iter126));
+      xfer += oprot->writeString((*_iter168));
     }
     xfer += oprot->writeListEnd();
   }
@@ -2501,15 +3429,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->skewedColValues.size()));
-    std::vector<std::vector<std::string> > ::const_iterator _iter127;
-    for (_iter127 = this->skewedColValues.begin(); _iter127 != this->skewedColValues.end(); ++_iter127)
+    std::vector<std::vector<std::string> > ::const_iterator _iter169;
+    for (_iter169 = this->skewedColValues.begin(); _iter169 != this->skewedColValues.end(); ++_iter169)
     {
       {
-        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter127).size()));
-        std::vector<std::string> ::const_iterator _iter128;
-        for (_iter128 = (*_iter127).begin(); _iter128 != (*_iter127).end(); ++_iter128)
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter169).size()));
+        std::vector<std::string> ::const_iterator _iter170;
+        for (_iter170 = (*_iter169).begin(); _iter170 != (*_iter169).end(); ++_iter170)
         {
-          xfer += oprot->writeString((*_iter128));
+          xfer += oprot->writeString((*_iter170));
         }
         xfer += oprot->writeListEnd();
       }
@@ -2521,19 +3449,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3);
   {
     xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColValueLocationMaps.size()));
-    std::map<std::vector<std::string> , std::string> ::const_iterator _iter129;
-    for (_iter129 = this->skewedColValueLocationMaps.begin(); _iter129 != this->skewedColValueLocationMaps.end(); ++_iter129)
+    std::map<std::vector<std::string> , std::string> ::const_iterator _iter171;
+    for (_iter171 = this->skewedColValueLocationMaps.begin(); _iter171 != this->skewedColValueLocationMaps.end(); ++_iter171)
     {
       {
-        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter129->first.size()));
-        std::vector<std::string> ::const_iterator _iter130;
-        for (_iter130 = _iter129->first.begin(); _iter130 != _iter129->first.end(); ++_iter130)
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter171->first.size()));
+        std::vector<std::string> ::const_iterator _iter172;
+        for (_iter172 = _iter171->first.begin(); _iter172 != _iter171->first.end(); ++_iter172)
         {
-          xfer += oprot->writeString((*_iter130));
+          xfer += oprot->writeString((*_iter172));
         }
         xfer += oprot->writeListEnd();
       }
-      xfer += oprot->writeString(_iter129->second);
+      xfer += oprot->writeString(_iter171->second);
     }
     xfer += oprot->writeMapEnd();
   }
@@ -2541,6 +3469,7 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
 
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
+  oprot->decrementRecursionDepth();
   return xfer;
 }
 
@@ -2552,6 +3481,84 @@ void swap(SkewedInfo &a, SkewedInfo &b) {
   swap(a.__isset, b.__isset);
 }
 
+SkewedInfo::SkewedInfo(const SkewedInfo& other173) {
+  skewedColNames = other173.skewedColNames;
+  skewedColValues = other173.skewedColValues;
+  skewedColValueLocationMaps = other173.skewedColValueLocationMaps;
+  __isset = other173.__isset;
+}
+SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other174) {
+  skewedColNames = other174.skewedColNames;
+  skewedColValues = other174.skewedColValues;
+  skewedColValueLocationMaps = other174.skewedColValueLocationMaps;
+  __isset = other174.__isset;
+  return *this;
+}
+std::ostream& operator<<(std::ostream& out, const SkewedInfo& obj) {
+  using apache::thrift::to_string;
+  out << "SkewedInfo(";
+  out << "skewedColNames=" << to_string(obj.skewedColNames);
+  out << ", " << "skewedColValues=" << to_string(obj.skewedColValues);
+  out << ", " << "skewedColValueLocationMaps=" << to_string(obj.skewedColValueLocationMaps);
+  out << ")";
+  return out;
+}
+
+
+StorageDescriptor::~StorageDescriptor() throw() {
+}
+
+
+void StorageDescriptor::__set_cols(const std::vector<FieldSchema> & val) {
+  this->cols = val;
+}
+
+void StorageDescriptor::__set_location(const std::string& val) {
+  this->location = val;
+}
+
+void StorageDescriptor::__set_inputFormat(const std::string& val) {
+  this->inputFormat = val;
+}
+
+void StorageDescriptor::__set_outputFormat(const std::string& val) {
+  this->outputFormat = val;
+}
+
+void StorageDescriptor::__set_compressed(const bool val) {
+  this->compressed = val;
+}
+
+void StorageDescriptor::__set_numBuckets(const int32_t val) {
+  this->numBuckets = val;
+}
+
+void StorageDescriptor::__set_serdeInfo(const SerDeInfo& val) {
+  this

<TRUNCATED>