[12/15] hive git commit: HIVE-13349: Metastore Changes : API calls for retrieving primary keys and foreign keys information (Hari Subramaniyan, reviewed by Ashutosh Chauhan)

[harisankar]

http://git-wip-us.apache.org/repos/asf/hive/blob/55375ec1/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 2695ffa..8da883d 100644
--- a/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
@@ -392,30 +392,43 @@ void FieldSchema::printTo(std::ostream& out) const {
 }
 
 
-Type::~Type() throw() {
+SQLPrimaryKey::~SQLPrimaryKey() throw() {
 }
 
 
-void Type::__set_name(const std::string& val) {
-  this->name = val;
+void SQLPrimaryKey::__set_table_db(const std::string& val) {
+  this->table_db = val;
 }
 
-void Type::__set_type1(const std::string& val) {
-  this->type1 = val;
-__isset.type1 = true;
+void SQLPrimaryKey::__set_table_name(const std::string& val) {
+  this->table_name = val;
 }
 
-void Type::__set_type2(const std::string& val) {
-  this->type2 = val;
-__isset.type2 = true;
+void SQLPrimaryKey::__set_column_name(const std::string& val) {
+  this->column_name = val;
 }
 
-void Type::__set_fields(const std::vector<FieldSchema> & val) {
-  this->fields = val;
-__isset.fields = true;
+void SQLPrimaryKey::__set_key_seq(const int32_t val) {
+  this->key_seq = val;
 }
 
-uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) {
+void SQLPrimaryKey::__set_pk_name(const std::string& val) {
+  this->pk_name = val;
+}
+
+void SQLPrimaryKey::__set_enable_cstr(const bool val) {
+  this->enable_cstr = val;
+}
+
+void SQLPrimaryKey::__set_validate_cstr(const bool val) {
+  this->validate_cstr = val;
+}
+
+void SQLPrimaryKey::__set_rely_cstr(const bool val) {
+  this->rely_cstr = val;
+}
+
+uint32_t SQLPrimaryKey::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -438,44 +451,64 @@ uint32_t 
Type::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->name);
-          this->__isset.name = true;
+          xfer += iprot->readString(this->table_db);
+          this->__isset.table_db = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->type1);
-          this->__isset.type1 = true;
+          xfer += iprot->readString(this->table_name);
+          this->__isset.table_name = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->type2);
-          this->__isset.type2 = true;
+          xfer += iprot->readString(this->column_name);
+          this->__isset.column_name = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->fields.clear();
-            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[_i8].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.fields = true;
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->key_seq);
+          this->__isset.key_seq = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->pk_name);
+          this->__isset.pk_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->enable_cstr);
+          this->__isset.enable_cstr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->validate_cstr);
+          this->__isset.validate_cstr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->rely_cstr);
+          this->__isset.rely_cstr = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -492,103 +525,160 @@ uint32_t 
Type::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t SQLPrimaryKey::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Type");
+  xfer += oprot->writeStructBegin("SQLPrimaryKey");
 
-  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 
1);
-  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldBegin("table_db", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->table_db);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("table_name", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->table_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("column_name", 
::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->column_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 
4);
+  xfer += oprot->writeI32(this->key_seq);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("pk_name", 
::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->pk_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("enable_cstr", 
::apache::thrift::protocol::T_BOOL, 6);
+  xfer += oprot->writeBool(this->enable_cstr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("validate_cstr", 
::apache::thrift::protocol::T_BOOL, 7);
+  xfer += oprot->writeBool(this->validate_cstr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("rely_cstr", 
::apache::thrift::protocol::T_BOOL, 8);
+  xfer += oprot->writeBool(this->rely_cstr);
   xfer += oprot->writeFieldEnd();
 
-  if (this->__isset.type1) {
-    xfer += oprot->writeFieldBegin("type1", 
::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeString(this->type1);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.type2) {
-    xfer += oprot->writeFieldBegin("type2", 
::apache::thrift::protocol::T_STRING, 3);
-    xfer += oprot->writeString(this->type2);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.fields) {
-    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 _iter9;
-      for (_iter9 = this->fields.begin(); _iter9 != this->fields.end(); 
++_iter9)
-      {
-        xfer += (*_iter9).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
-    xfer += oprot->writeFieldEnd();
-  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(Type &a, Type &b) {
+void swap(SQLPrimaryKey &a, SQLPrimaryKey &b) {
   using ::std::swap;
-  swap(a.name, b.name);
-  swap(a.type1, b.type1);
-  swap(a.type2, b.type2);
-  swap(a.fields, b.fields);
+  swap(a.table_db, b.table_db);
+  swap(a.table_name, b.table_name);
+  swap(a.column_name, b.column_name);
+  swap(a.key_seq, b.key_seq);
+  swap(a.pk_name, b.pk_name);
+  swap(a.enable_cstr, b.enable_cstr);
+  swap(a.validate_cstr, b.validate_cstr);
+  swap(a.rely_cstr, b.rely_cstr);
   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;
+SQLPrimaryKey::SQLPrimaryKey(const SQLPrimaryKey& other4) {
+  table_db = other4.table_db;
+  table_name = other4.table_name;
+  column_name = other4.column_name;
+  key_seq = other4.key_seq;
+  pk_name = other4.pk_name;
+  enable_cstr = other4.enable_cstr;
+  validate_cstr = other4.validate_cstr;
+  rely_cstr = other4.rely_cstr;
+  __isset = other4.__isset;
+}
+SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other5) {
+  table_db = other5.table_db;
+  table_name = other5.table_name;
+  column_name = other5.column_name;
+  key_seq = other5.key_seq;
+  pk_name = other5.pk_name;
+  enable_cstr = other5.enable_cstr;
+  validate_cstr = other5.validate_cstr;
+  rely_cstr = other5.rely_cstr;
+  __isset = other5.__isset;
   return *this;
 }
-void Type::printTo(std::ostream& out) const {
+void SQLPrimaryKey::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "Type(";
-  out << "name=" << to_string(name);
-  out << ", " << "type1="; (__isset.type1 ? (out << to_string(type1)) : (out 
<< "<null>"));
-  out << ", " << "type2="; (__isset.type2 ? (out << to_string(type2)) : (out 
<< "<null>"));
-  out << ", " << "fields="; (__isset.fields ? (out << to_string(fields)) : 
(out << "<null>"));
+  out << "SQLPrimaryKey(";
+  out << "table_db=" << to_string(table_db);
+  out << ", " << "table_name=" << to_string(table_name);
+  out << ", " << "column_name=" << to_string(column_name);
+  out << ", " << "key_seq=" << to_string(key_seq);
+  out << ", " << "pk_name=" << to_string(pk_name);
+  out << ", " << "enable_cstr=" << to_string(enable_cstr);
+  out << ", " << "validate_cstr=" << to_string(validate_cstr);
+  out << ", " << "rely_cstr=" << to_string(rely_cstr);
   out << ")";
 }
 
 
-HiveObjectRef::~HiveObjectRef() throw() {
+SQLForeignKey::~SQLForeignKey() throw() {
 }
 
 
-void HiveObjectRef::__set_objectType(const HiveObjectType::type val) {
-  this->objectType = val;
+void SQLForeignKey::__set_pktable_db(const std::string& val) {
+  this->pktable_db = val;
 }
 
-void HiveObjectRef::__set_dbName(const std::string& val) {
-  this->dbName = val;
+void SQLForeignKey::__set_pktable_name(const std::string& val) {
+  this->pktable_name = val;
 }
 
-void HiveObjectRef::__set_objectName(const std::string& val) {
-  this->objectName = val;
+void SQLForeignKey::__set_pkcolumn_name(const std::string& val) {
+  this->pkcolumn_name = val;
 }
 
-void HiveObjectRef::__set_partValues(const std::vector<std::string> & val) {
-  this->partValues = val;
+void SQLForeignKey::__set_fktable_db(const std::string& val) {
+  this->fktable_db = val;
 }
 
-void HiveObjectRef::__set_columnName(const std::string& val) {
-  this->columnName = val;
+void SQLForeignKey::__set_fktable_name(const std::string& val) {
+  this->fktable_name = val;
 }
 
-uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
+void SQLForeignKey::__set_fkcolumn_name(const std::string& val) {
+  this->fkcolumn_name = val;
+}
+
+void SQLForeignKey::__set_key_seq(const int32_t val) {
+  this->key_seq = val;
+}
+
+void SQLForeignKey::__set_update_rule(const int32_t val) {
+  this->update_rule = val;
+}
+
+void SQLForeignKey::__set_delete_rule(const int32_t val) {
+  this->delete_rule = val;
+}
+
+void SQLForeignKey::__set_fk_name(const std::string& val) {
+  this->fk_name = val;
+}
+
+void SQLForeignKey::__set_pk_name(const std::string& val) {
+  this->pk_name = val;
+}
+
+void SQLForeignKey::__set_enable_cstr(const bool val) {
+  this->enable_cstr = val;
+}
+
+void SQLForeignKey::__set_validate_cstr(const bool val) {
+  this->validate_cstr = val;
+}
+
+void SQLForeignKey::__set_rely_cstr(const bool val) {
+  this->rely_cstr = val;
+}
+
+uint32_t SQLForeignKey::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -610,55 +700,113 @@ uint32_t 
HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast12;
-          xfer += iprot->readI32(ecast12);
-          this->objectType = (HiveObjectType::type)ecast12;
-          this->__isset.objectType = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->pktable_db);
+          this->__isset.pktable_db = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->dbName);
-          this->__isset.dbName = true;
+          xfer += iprot->readString(this->pktable_name);
+          this->__isset.pktable_name = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->objectName);
-          this->__isset.objectName = true;
+          xfer += iprot->readString(this->pkcolumn_name);
+          this->__isset.pkcolumn_name = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->partValues.clear();
-            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[_i17]);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.partValues = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->fktable_db);
+          this->__isset.fktable_db = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 5:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->columnName);
-          this->__isset.columnName = true;
+          xfer += iprot->readString(this->fktable_name);
+          this->__isset.fktable_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->fkcolumn_name);
+          this->__isset.fkcolumn_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->key_seq);
+          this->__isset.key_seq = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->update_rule);
+          this->__isset.update_rule = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->delete_rule);
+          this->__isset.delete_rule = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 10:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->fk_name);
+          this->__isset.fk_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 11:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->pk_name);
+          this->__isset.pk_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 12:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->enable_cstr);
+          this->__isset.enable_cstr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 13:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->validate_cstr);
+          this->__isset.validate_cstr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 14:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->rely_cstr);
+          this->__isset.rely_cstr = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -675,37 +823,65 @@ uint32_t 
HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
+uint32_t SQLForeignKey::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("HiveObjectRef");
+  xfer += oprot->writeStructBegin("SQLForeignKey");
 
-  xfer += oprot->writeFieldBegin("objectType", 
::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32((int32_t)this->objectType);
+  xfer += oprot->writeFieldBegin("pktable_db", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->pktable_db);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->dbName);
+  xfer += oprot->writeFieldBegin("pktable_name", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->pktable_name);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("objectName", 
::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString(this->objectName);
+  xfer += oprot->writeFieldBegin("pkcolumn_name", 
::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->pkcolumn_name);
   xfer += oprot->writeFieldEnd();
 
-  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 _iter18;
-    for (_iter18 = this->partValues.begin(); _iter18 != 
this->partValues.end(); ++_iter18)
-    {
-      xfer += oprot->writeString((*_iter18));
-    }
-    xfer += oprot->writeListEnd();
-  }
+  xfer += oprot->writeFieldBegin("fktable_db", 
::apache::thrift::protocol::T_STRING, 4);
+  xfer += oprot->writeString(this->fktable_db);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("columnName", 
::apache::thrift::protocol::T_STRING, 5);
-  xfer += oprot->writeString(this->columnName);
+  xfer += oprot->writeFieldBegin("fktable_name", 
::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->fktable_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("fkcolumn_name", 
::apache::thrift::protocol::T_STRING, 6);
+  xfer += oprot->writeString(this->fkcolumn_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 
7);
+  xfer += oprot->writeI32(this->key_seq);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("update_rule", 
::apache::thrift::protocol::T_I32, 8);
+  xfer += oprot->writeI32(this->update_rule);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("delete_rule", 
::apache::thrift::protocol::T_I32, 9);
+  xfer += oprot->writeI32(this->delete_rule);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("fk_name", 
::apache::thrift::protocol::T_STRING, 10);
+  xfer += oprot->writeString(this->fk_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("pk_name", 
::apache::thrift::protocol::T_STRING, 11);
+  xfer += oprot->writeString(this->pk_name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("enable_cstr", 
::apache::thrift::protocol::T_BOOL, 12);
+  xfer += oprot->writeBool(this->enable_cstr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("validate_cstr", 
::apache::thrift::protocol::T_BOOL, 13);
+  xfer += oprot->writeBool(this->validate_cstr);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("rely_cstr", 
::apache::thrift::protocol::T_BOOL, 14);
+  xfer += oprot->writeBool(this->rely_cstr);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -713,70 +889,105 @@ uint32_t 
HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) cons
   return xfer;
 }
 
-void swap(HiveObjectRef &a, HiveObjectRef &b) {
+void swap(SQLForeignKey &a, SQLForeignKey &b) {
   using ::std::swap;
-  swap(a.objectType, b.objectType);
-  swap(a.dbName, b.dbName);
-  swap(a.objectName, b.objectName);
-  swap(a.partValues, b.partValues);
-  swap(a.columnName, b.columnName);
+  swap(a.pktable_db, b.pktable_db);
+  swap(a.pktable_name, b.pktable_name);
+  swap(a.pkcolumn_name, b.pkcolumn_name);
+  swap(a.fktable_db, b.fktable_db);
+  swap(a.fktable_name, b.fktable_name);
+  swap(a.fkcolumn_name, b.fkcolumn_name);
+  swap(a.key_seq, b.key_seq);
+  swap(a.update_rule, b.update_rule);
+  swap(a.delete_rule, b.delete_rule);
+  swap(a.fk_name, b.fk_name);
+  swap(a.pk_name, b.pk_name);
+  swap(a.enable_cstr, b.enable_cstr);
+  swap(a.validate_cstr, b.validate_cstr);
+  swap(a.rely_cstr, b.rely_cstr);
   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;
+SQLForeignKey::SQLForeignKey(const SQLForeignKey& other6) {
+  pktable_db = other6.pktable_db;
+  pktable_name = other6.pktable_name;
+  pkcolumn_name = other6.pkcolumn_name;
+  fktable_db = other6.fktable_db;
+  fktable_name = other6.fktable_name;
+  fkcolumn_name = other6.fkcolumn_name;
+  key_seq = other6.key_seq;
+  update_rule = other6.update_rule;
+  delete_rule = other6.delete_rule;
+  fk_name = other6.fk_name;
+  pk_name = other6.pk_name;
+  enable_cstr = other6.enable_cstr;
+  validate_cstr = other6.validate_cstr;
+  rely_cstr = other6.rely_cstr;
+  __isset = other6.__isset;
+}
+SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other7) {
+  pktable_db = other7.pktable_db;
+  pktable_name = other7.pktable_name;
+  pkcolumn_name = other7.pkcolumn_name;
+  fktable_db = other7.fktable_db;
+  fktable_name = other7.fktable_name;
+  fkcolumn_name = other7.fkcolumn_name;
+  key_seq = other7.key_seq;
+  update_rule = other7.update_rule;
+  delete_rule = other7.delete_rule;
+  fk_name = other7.fk_name;
+  pk_name = other7.pk_name;
+  enable_cstr = other7.enable_cstr;
+  validate_cstr = other7.validate_cstr;
+  rely_cstr = other7.rely_cstr;
+  __isset = other7.__isset;
   return *this;
 }
-void HiveObjectRef::printTo(std::ostream& out) const {
+void SQLForeignKey::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "HiveObjectRef(";
-  out << "objectType=" << to_string(objectType);
-  out << ", " << "dbName=" << to_string(dbName);
-  out << ", " << "objectName=" << to_string(objectName);
-  out << ", " << "partValues=" << to_string(partValues);
-  out << ", " << "columnName=" << to_string(columnName);
+  out << "SQLForeignKey(";
+  out << "pktable_db=" << to_string(pktable_db);
+  out << ", " << "pktable_name=" << to_string(pktable_name);
+  out << ", " << "pkcolumn_name=" << to_string(pkcolumn_name);
+  out << ", " << "fktable_db=" << to_string(fktable_db);
+  out << ", " << "fktable_name=" << to_string(fktable_name);
+  out << ", " << "fkcolumn_name=" << to_string(fkcolumn_name);
+  out << ", " << "key_seq=" << to_string(key_seq);
+  out << ", " << "update_rule=" << to_string(update_rule);
+  out << ", " << "delete_rule=" << to_string(delete_rule);
+  out << ", " << "fk_name=" << to_string(fk_name);
+  out << ", " << "pk_name=" << to_string(pk_name);
+  out << ", " << "enable_cstr=" << to_string(enable_cstr);
+  out << ", " << "validate_cstr=" << to_string(validate_cstr);
+  out << ", " << "rely_cstr=" << to_string(rely_cstr);
   out << ")";
 }
 
 
-PrivilegeGrantInfo::~PrivilegeGrantInfo() throw() {
+Type::~Type() throw() {
 }
 
 
-void PrivilegeGrantInfo::__set_privilege(const std::string& val) {
-  this->privilege = val;
-}
-
-void PrivilegeGrantInfo::__set_createTime(const int32_t val) {
-  this->createTime = val;
+void Type::__set_name(const std::string& val) {
+  this->name = val;
 }
 
-void PrivilegeGrantInfo::__set_grantor(const std::string& val) {
-  this->grantor = val;
+void Type::__set_type1(const std::string& val) {
+  this->type1 = val;
+__isset.type1 = true;
 }
 
-void PrivilegeGrantInfo::__set_grantorType(const PrincipalType::type val) {
-  this->grantorType = val;
+void Type::__set_type2(const std::string& val) {
+  this->type2 = val;
+__isset.type2 = true;
 }
 
-void PrivilegeGrantInfo::__set_grantOption(const bool val) {
-  this->grantOption = val;
+void Type::__set_fields(const std::vector<FieldSchema> & val) {
+  this->fields = val;
+__isset.fields = true;
 }
 
-uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+uint32_t Type::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -799,42 +1010,44 @@ uint32_t 
PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot)
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->privilege);
-          this->__isset.privilege = true;
+          xfer += iprot->readString(this->name);
+          this->__isset.name = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->createTime);
-          this->__isset.createTime = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->type1);
+          this->__isset.type1 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->grantor);
-          this->__isset.grantor = true;
+          xfer += iprot->readString(this->type2);
+          this->__isset.type2 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 4:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast21;
-          xfer += iprot->readI32(ecast21);
-          this->grantorType = (PrincipalType::type)ecast21;
-          this->__isset.grantorType = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->grantOption);
-          this->__isset.grantOption = true;
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->fields.clear();
+            uint32_t _size8;
+            ::apache::thrift::protocol::TType _etype11;
+            xfer += iprot->readListBegin(_etype11, _size8);
+            this->fields.resize(_size8);
+            uint32_t _i12;
+            for (_i12 = 0; _i12 < _size8; ++_i12)
+            {
+              xfer += this->fields[_i12].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.fields = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -851,96 +1064,103 @@ uint32_t 
PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* iprot)
   return xfer;
 }
 
-uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+uint32_t Type::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PrivilegeGrantInfo");
-
-  xfer += oprot->writeFieldBegin("privilege", 
::apache::thrift::protocol::T_STRING, 1);
-  xfer += oprot->writeString(this->privilege);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("createTime", 
::apache::thrift::protocol::T_I32, 2);
-  xfer += oprot->writeI32(this->createTime);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("grantor", 
::apache::thrift::protocol::T_STRING, 3);
-  xfer += oprot->writeString(this->grantor);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("grantorType", 
::apache::thrift::protocol::T_I32, 4);
-  xfer += oprot->writeI32((int32_t)this->grantorType);
-  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeStructBegin("Type");
 
-  xfer += oprot->writeFieldBegin("grantOption", 
::apache::thrift::protocol::T_BOOL, 5);
-  xfer += oprot->writeBool(this->grantOption);
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 
1);
+  xfer += oprot->writeString(this->name);
   xfer += oprot->writeFieldEnd();
 
+  if (this->__isset.type1) {
+    xfer += oprot->writeFieldBegin("type1", 
::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->type1);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.type2) {
+    xfer += oprot->writeFieldBegin("type2", 
::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->type2);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.fields) {
+    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 _iter13;
+      for (_iter13 = this->fields.begin(); _iter13 != this->fields.end(); 
++_iter13)
+      {
+        xfer += (*_iter13).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) {
+void swap(Type &a, Type &b) {
   using ::std::swap;
-  swap(a.privilege, b.privilege);
-  swap(a.createTime, b.createTime);
-  swap(a.grantor, b.grantor);
-  swap(a.grantorType, b.grantorType);
-  swap(a.grantOption, b.grantOption);
+  swap(a.name, b.name);
+  swap(a.type1, b.type1);
+  swap(a.type2, b.type2);
+  swap(a.fields, b.fields);
   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;
+Type::Type(const Type& other14) {
+  name = other14.name;
+  type1 = other14.type1;
+  type2 = other14.type2;
+  fields = other14.fields;
+  __isset = other14.__isset;
+}
+Type& Type::operator=(const Type& other15) {
+  name = other15.name;
+  type1 = other15.type1;
+  type2 = other15.type2;
+  fields = other15.fields;
+  __isset = other15.__isset;
   return *this;
 }
-void PrivilegeGrantInfo::printTo(std::ostream& out) const {
+void Type::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "PrivilegeGrantInfo(";
-  out << "privilege=" << to_string(privilege);
-  out << ", " << "createTime=" << to_string(createTime);
-  out << ", " << "grantor=" << to_string(grantor);
-  out << ", " << "grantorType=" << to_string(grantorType);
-  out << ", " << "grantOption=" << to_string(grantOption);
+  out << "Type(";
+  out << "name=" << to_string(name);
+  out << ", " << "type1="; (__isset.type1 ? (out << to_string(type1)) : (out 
<< "<null>"));
+  out << ", " << "type2="; (__isset.type2 ? (out << to_string(type2)) : (out 
<< "<null>"));
+  out << ", " << "fields="; (__isset.fields ? (out << to_string(fields)) : 
(out << "<null>"));
   out << ")";
 }
 
 
-HiveObjectPrivilege::~HiveObjectPrivilege() throw() {
+HiveObjectRef::~HiveObjectRef() throw() {
 }
 
 
-void HiveObjectPrivilege::__set_hiveObject(const HiveObjectRef& val) {
-  this->hiveObject = val;
+void HiveObjectRef::__set_objectType(const HiveObjectType::type val) {
+  this->objectType = val;
 }
 
-void HiveObjectPrivilege::__set_principalName(const std::string& val) {
-  this->principalName = val;
+void HiveObjectRef::__set_dbName(const std::string& val) {
+  this->dbName = val;
 }
 
-void HiveObjectPrivilege::__set_principalType(const PrincipalType::type val) {
-  this->principalType = val;
+void HiveObjectRef::__set_objectName(const std::string& val) {
+  this->objectName = val;
 }
 
-void HiveObjectPrivilege::__set_grantInfo(const PrivilegeGrantInfo& val) {
-  this->grantInfo = val;
+void HiveObjectRef::__set_partValues(const std::vector<std::string> & val) {
+  this->partValues = val;
 }
 
-uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+void HiveObjectRef::__set_columnName(const std::string& val) {
+  this->columnName = val;
+}
+
+uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -962,35 +1182,55 @@ uint32_t 
HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot)
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->hiveObject.read(iprot);
-          this->__isset.hiveObject = true;
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast16;
+          xfer += iprot->readI32(ecast16);
+          this->objectType = (HiveObjectType::type)ecast16;
+          this->__isset.objectType = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->principalName);
-          this->__isset.principalName = true;
+          xfer += iprot->readString(this->dbName);
+          this->__isset.dbName = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast24;
-          xfer += iprot->readI32(ecast24);
-          this->principalType = (PrincipalType::type)ecast24;
-          this->__isset.principalType = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->objectName);
+          this->__isset.objectName = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 4:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->grantInfo.read(iprot);
-          this->__isset.grantInfo = true;
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->partValues.clear();
+            uint32_t _size17;
+            ::apache::thrift::protocol::TType _etype20;
+            xfer += iprot->readListBegin(_etype20, _size17);
+            this->partValues.resize(_size17);
+            uint32_t _i21;
+            for (_i21 = 0; _i21 < _size17; ++_i21)
+            {
+              xfer += iprot->readString(this->partValues[_i21]);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.partValues = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->columnName);
+          this->__isset.columnName = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -1007,25 +1247,37 @@ uint32_t 
HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* iprot)
   return xfer;
 }
 
-uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("HiveObjectPrivilege");
+  xfer += oprot->writeStructBegin("HiveObjectRef");
 
-  xfer += oprot->writeFieldBegin("hiveObject", 
::apache::thrift::protocol::T_STRUCT, 1);
-  xfer += this->hiveObject.write(oprot);
+  xfer += oprot->writeFieldBegin("objectType", 
::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->objectType);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("principalName", 
::apache::thrift::protocol::T_STRING, 2);
-  xfer += oprot->writeString(this->principalName);
+  xfer += oprot->writeFieldBegin("dbName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->dbName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("principalType", 
::apache::thrift::protocol::T_I32, 3);
-  xfer += oprot->writeI32((int32_t)this->principalType);
+  xfer += oprot->writeFieldBegin("objectName", 
::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->objectName);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("grantInfo", 
::apache::thrift::protocol::T_STRUCT, 4);
-  xfer += this->grantInfo.write(oprot);
+  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 _iter22;
+    for (_iter22 = this->partValues.begin(); _iter22 != 
this->partValues.end(); ++_iter22)
+    {
+      xfer += oprot->writeString((*_iter22));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("columnName", 
::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->columnName);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -1033,52 +1285,72 @@ uint32_t 
HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* oprot
   return xfer;
 }
 
-void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) {
+void swap(HiveObjectRef &a, HiveObjectRef &b) {
   using ::std::swap;
-  swap(a.hiveObject, b.hiveObject);
-  swap(a.principalName, b.principalName);
-  swap(a.principalType, b.principalType);
-  swap(a.grantInfo, b.grantInfo);
+  swap(a.objectType, b.objectType);
+  swap(a.dbName, b.dbName);
+  swap(a.objectName, b.objectName);
+  swap(a.partValues, b.partValues);
+  swap(a.columnName, b.columnName);
   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;
+HiveObjectRef::HiveObjectRef(const HiveObjectRef& other23) {
+  objectType = other23.objectType;
+  dbName = other23.dbName;
+  objectName = other23.objectName;
+  partValues = other23.partValues;
+  columnName = other23.columnName;
+  __isset = other23.__isset;
 }
-HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& 
other26) {
-  hiveObject = other26.hiveObject;
-  principalName = other26.principalName;
-  principalType = other26.principalType;
-  grantInfo = other26.grantInfo;
-  __isset = other26.__isset;
+HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other24) {
+  objectType = other24.objectType;
+  dbName = other24.dbName;
+  objectName = other24.objectName;
+  partValues = other24.partValues;
+  columnName = other24.columnName;
+  __isset = other24.__isset;
   return *this;
 }
-void HiveObjectPrivilege::printTo(std::ostream& out) const {
+void HiveObjectRef::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "HiveObjectPrivilege(";
-  out << "hiveObject=" << to_string(hiveObject);
-  out << ", " << "principalName=" << to_string(principalName);
-  out << ", " << "principalType=" << to_string(principalType);
-  out << ", " << "grantInfo=" << to_string(grantInfo);
+  out << "HiveObjectRef(";
+  out << "objectType=" << to_string(objectType);
+  out << ", " << "dbName=" << to_string(dbName);
+  out << ", " << "objectName=" << to_string(objectName);
+  out << ", " << "partValues=" << to_string(partValues);
+  out << ", " << "columnName=" << to_string(columnName);
   out << ")";
 }
 
 
-PrivilegeBag::~PrivilegeBag() throw() {
+PrivilegeGrantInfo::~PrivilegeGrantInfo() throw() {
 }
 
 
-void PrivilegeBag::__set_privileges(const std::vector<HiveObjectPrivilege> & 
val) {
-  this->privileges = val;
+void PrivilegeGrantInfo::__set_privilege(const std::string& val) {
+  this->privilege = val;
 }
 
-uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
+void PrivilegeGrantInfo::__set_createTime(const int32_t val) {
+  this->createTime = val;
+}
 
-  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+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;
+}
+
+uint32_t PrivilegeGrantInfo::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
   std::string fname;
   ::apache::thrift::protocol::TType ftype;
@@ -1098,21 +1370,43 @@ uint32_t 
PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->privileges.clear();
-            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[_i31].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.privileges = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->privilege);
+          this->__isset.privilege = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->createTime);
+          this->__isset.createTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->grantor);
+          this->__isset.grantor = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast25;
+          xfer += iprot->readI32(ecast25);
+          this->grantorType = (PrincipalType::type)ecast25;
+          this->__isset.grantorType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->grantOption);
+          this->__isset.grantOption = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -1129,21 +1423,29 @@ uint32_t 
PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
+uint32_t PrivilegeGrantInfo::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PrivilegeBag");
+  xfer += oprot->writeStructBegin("PrivilegeGrantInfo");
 
-  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 _iter32;
-    for (_iter32 = this->privileges.begin(); _iter32 != 
this->privileges.end(); ++_iter32)
-    {
-      xfer += (*_iter32).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
+  xfer += oprot->writeFieldBegin("privilege", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->privilege);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("createTime", 
::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->createTime);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("grantor", 
::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->grantor);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("grantorType", 
::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((int32_t)this->grantorType);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("grantOption", 
::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool(this->grantOption);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -1151,46 +1453,66 @@ uint32_t 
PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) const
   return xfer;
 }
 
-void swap(PrivilegeBag &a, PrivilegeBag &b) {
+void swap(PrivilegeGrantInfo &a, PrivilegeGrantInfo &b) {
   using ::std::swap;
-  swap(a.privileges, b.privileges);
+  swap(a.privilege, b.privilege);
+  swap(a.createTime, b.createTime);
+  swap(a.grantor, b.grantor);
+  swap(a.grantorType, b.grantorType);
+  swap(a.grantOption, b.grantOption);
   swap(a.__isset, b.__isset);
 }
 
-PrivilegeBag::PrivilegeBag(const PrivilegeBag& other33) {
-  privileges = other33.privileges;
-  __isset = other33.__isset;
+PrivilegeGrantInfo::PrivilegeGrantInfo(const PrivilegeGrantInfo& other26) {
+  privilege = other26.privilege;
+  createTime = other26.createTime;
+  grantor = other26.grantor;
+  grantorType = other26.grantorType;
+  grantOption = other26.grantOption;
+  __isset = other26.__isset;
 }
-PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other34) {
-  privileges = other34.privileges;
-  __isset = other34.__isset;
+PrivilegeGrantInfo& PrivilegeGrantInfo::operator=(const PrivilegeGrantInfo& 
other27) {
+  privilege = other27.privilege;
+  createTime = other27.createTime;
+  grantor = other27.grantor;
+  grantorType = other27.grantorType;
+  grantOption = other27.grantOption;
+  __isset = other27.__isset;
   return *this;
 }
-void PrivilegeBag::printTo(std::ostream& out) const {
+void PrivilegeGrantInfo::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "PrivilegeBag(";
-  out << "privileges=" << to_string(privileges);
+  out << "PrivilegeGrantInfo(";
+  out << "privilege=" << to_string(privilege);
+  out << ", " << "createTime=" << to_string(createTime);
+  out << ", " << "grantor=" << to_string(grantor);
+  out << ", " << "grantorType=" << to_string(grantorType);
+  out << ", " << "grantOption=" << to_string(grantOption);
   out << ")";
 }
 
 
-PrincipalPrivilegeSet::~PrincipalPrivilegeSet() throw() {
+HiveObjectPrivilege::~HiveObjectPrivilege() throw() {
 }
 
 
-void PrincipalPrivilegeSet::__set_userPrivileges(const std::map<std::string, 
std::vector<PrivilegeGrantInfo> > & val) {
-  this->userPrivileges = val;
+void HiveObjectPrivilege::__set_hiveObject(const HiveObjectRef& val) {
+  this->hiveObject = val;
 }
 
-void PrincipalPrivilegeSet::__set_groupPrivileges(const std::map<std::string, 
std::vector<PrivilegeGrantInfo> > & val) {
-  this->groupPrivileges = val;
+void HiveObjectPrivilege::__set_principalName(const std::string& val) {
+  this->principalName = val;
 }
 
-void PrincipalPrivilegeSet::__set_rolePrivileges(const std::map<std::string, 
std::vector<PrivilegeGrantInfo> > & val) {
-  this->rolePrivileges = val;
+void HiveObjectPrivilege::__set_principalType(const PrincipalType::type val) {
+  this->principalType = val;
 }
 
-uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+void HiveObjectPrivilege::__set_grantInfo(const PrivilegeGrantInfo& val) {
+  this->grantInfo = val;
+}
+
+uint32_t HiveObjectPrivilege::read(::apache::thrift::protocol::TProtocol* 
iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -1212,106 +1534,35 @@ uint32_t 
PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            this->userPrivileges.clear();
-            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 _key40;
-              xfer += iprot->readString(_key40);
-              std::vector<PrivilegeGrantInfo> & _val41 = 
this->userPrivileges[_key40];
-              {
-                _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 += _val41[_i46].read(iprot);
-                }
-                xfer += iprot->readListEnd();
-              }
-            }
-            xfer += iprot->readMapEnd();
-          }
-          this->__isset.userPrivileges = true;
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->hiveObject.read(iprot);
+          this->__isset.hiveObject = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            this->groupPrivileges.clear();
-            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 _key52;
-              xfer += iprot->readString(_key52);
-              std::vector<PrivilegeGrantInfo> & _val53 = 
this->groupPrivileges[_key52];
-              {
-                _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 += _val53[_i58].read(iprot);
-                }
-                xfer += iprot->readListEnd();
-              }
-            }
-            xfer += iprot->readMapEnd();
-          }
-          this->__isset.groupPrivileges = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->principalName);
+          this->__isset.principalName = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
-        if (ftype == ::apache::thrift::protocol::T_MAP) {
-          {
-            this->rolePrivileges.clear();
-            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 _key64;
-              xfer += iprot->readString(_key64);
-              std::vector<PrivilegeGrantInfo> & _val65 = 
this->rolePrivileges[_key64];
-              {
-                _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 += _val65[_i70].read(iprot);
-                }
-                xfer += iprot->readListEnd();
-              }
-            }
-            xfer += iprot->readMapEnd();
-          }
-          this->__isset.rolePrivileges = true;
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast28;
+          xfer += iprot->readI32(ecast28);
+          this->principalType = (PrincipalType::type)ecast28;
+          this->__isset.principalType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->grantInfo.read(iprot);
+          this->__isset.grantInfo = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -1328,72 +1579,25 @@ uint32_t 
PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* ipro
   return xfer;
 }
 
-uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+uint32_t HiveObjectPrivilege::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("PrincipalPrivilegeSet");
+  xfer += oprot->writeStructBegin("HiveObjectPrivilege");
 
-  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 
_iter71;
-    for (_iter71 = this->userPrivileges.begin(); _iter71 != 
this->userPrivileges.end(); ++_iter71)
-    {
-      xfer += oprot->writeString(_iter71->first);
-      {
-        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 += (*_iter72).write(oprot);
-        }
-        xfer += oprot->writeListEnd();
-      }
-    }
-    xfer += oprot->writeMapEnd();
-  }
+  xfer += oprot->writeFieldBegin("hiveObject", 
::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->hiveObject.write(oprot);
   xfer += oprot->writeFieldEnd();
 
-  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 
_iter73;
-    for (_iter73 = this->groupPrivileges.begin(); _iter73 != 
this->groupPrivileges.end(); ++_iter73)
-    {
-      xfer += oprot->writeString(_iter73->first);
-      {
-        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 += (*_iter74).write(oprot);
-        }
-        xfer += oprot->writeListEnd();
-      }
-    }
-    xfer += oprot->writeMapEnd();
-  }
+  xfer += oprot->writeFieldBegin("principalName", 
::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->principalName);
   xfer += oprot->writeFieldEnd();
 
-  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 
_iter75;
-    for (_iter75 = this->rolePrivileges.begin(); _iter75 != 
this->rolePrivileges.end(); ++_iter75)
-    {
-      xfer += oprot->writeString(_iter75->first);
-      {
-        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 += (*_iter76).write(oprot);
-        }
-        xfer += oprot->writeListEnd();
-      }
-    }
-    xfer += oprot->writeMapEnd();
-  }
+  xfer += oprot->writeFieldBegin("principalType", 
::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)this->principalType);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("grantInfo", 
::apache::thrift::protocol::T_STRUCT, 4);
+  xfer += this->grantInfo.write(oprot);
   xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldStop();
@@ -1401,55 +1605,50 @@ uint32_t 
PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* opr
   return xfer;
 }
 
-void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) {
+void swap(HiveObjectPrivilege &a, HiveObjectPrivilege &b) {
   using ::std::swap;
-  swap(a.userPrivileges, b.userPrivileges);
-  swap(a.groupPrivileges, b.groupPrivileges);
-  swap(a.rolePrivileges, b.rolePrivileges);
+  swap(a.hiveObject, b.hiveObject);
+  swap(a.principalName, b.principalName);
+  swap(a.principalType, b.principalType);
+  swap(a.grantInfo, b.grantInfo);
   swap(a.__isset, b.__isset);
 }
 
-PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& 
other77) {
-  userPrivileges = other77.userPrivileges;
-  groupPrivileges = other77.groupPrivileges;
-  rolePrivileges = other77.rolePrivileges;
-  __isset = other77.__isset;
+HiveObjectPrivilege::HiveObjectPrivilege(const HiveObjectPrivilege& other29) {
+  hiveObject = other29.hiveObject;
+  principalName = other29.principalName;
+  principalType = other29.principalType;
+  grantInfo = other29.grantInfo;
+  __isset = other29.__isset;
 }
-PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const 
PrincipalPrivilegeSet& other78) {
-  userPrivileges = other78.userPrivileges;
-  groupPrivileges = other78.groupPrivileges;
-  rolePrivileges = other78.rolePrivileges;
-  __isset = other78.__isset;
+HiveObjectPrivilege& HiveObjectPrivilege::operator=(const HiveObjectPrivilege& 
other30) {
+  hiveObject = other30.hiveObject;
+  principalName = other30.principalName;
+  principalType = other30.principalType;
+  grantInfo = other30.grantInfo;
+  __isset = other30.__isset;
   return *this;
 }
-void PrincipalPrivilegeSet::printTo(std::ostream& out) const {
+void HiveObjectPrivilege::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "PrincipalPrivilegeSet(";
-  out << "userPrivileges=" << to_string(userPrivileges);
-  out << ", " << "groupPrivileges=" << to_string(groupPrivileges);
-  out << ", " << "rolePrivileges=" << to_string(rolePrivileges);
+  out << "HiveObjectPrivilege(";
+  out << "hiveObject=" << to_string(hiveObject);
+  out << ", " << "principalName=" << to_string(principalName);
+  out << ", " << "principalType=" << to_string(principalType);
+  out << ", " << "grantInfo=" << to_string(grantInfo);
   out << ")";
 }
 
 
-GrantRevokePrivilegeRequest::~GrantRevokePrivilegeRequest() throw() {
+PrivilegeBag::~PrivilegeBag() throw() {
 }
 
 
-void GrantRevokePrivilegeRequest::__set_requestType(const 
GrantRevokeType::type val) {
-  this->requestType = val;
-}
-
-void GrantRevokePrivilegeRequest::__set_privileges(const PrivilegeBag& val) {
+void PrivilegeBag::__set_privileges(const std::vector<HiveObjectPrivilege> & 
val) {
   this->privileges = val;
 }
 
-void GrantRevokePrivilegeRequest::__set_revokeGrantOption(const bool val) {
-  this->revokeGrantOption = val;
-__isset.revokeGrantOption = true;
-}
-
-uint32_t 
GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol* iprot) 
{
+uint32_t PrivilegeBag::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -1471,31 +1670,25 @@ uint32_t 
GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast79;
-          xfer += iprot->readI32(ecast79);
-          this->requestType = (GrantRevokeType::type)ecast79;
-          this->__isset.requestType = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->privileges.read(iprot);
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->privileges.clear();
+            uint32_t _size31;
+            ::apache::thrift::protocol::TType _etype34;
+            xfer += iprot->readListBegin(_etype34, _size31);
+            this->privileges.resize(_size31);
+            uint32_t _i35;
+            for (_i35 = 0; _i35 < _size31; ++_i35)
+            {
+              xfer += this->privileges[_i35].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
           this->__isset.privileges = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->revokeGrantOption);
-          this->__isset.revokeGrantOption = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -1508,70 +1701,68 @@ uint32_t 
GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol
   return xfer;
 }
 
-uint32_t 
GrantRevokePrivilegeRequest::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+uint32_t PrivilegeBag::write(::apache::thrift::protocol::TProtocol* oprot) 
const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("GrantRevokePrivilegeRequest");
-
-  xfer += oprot->writeFieldBegin("requestType", 
::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32((int32_t)this->requestType);
-  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeStructBegin("PrivilegeBag");
 
-  xfer += oprot->writeFieldBegin("privileges", 
::apache::thrift::protocol::T_STRUCT, 2);
-  xfer += this->privileges.write(oprot);
+  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 _iter36;
+    for (_iter36 = this->privileges.begin(); _iter36 != 
this->privileges.end(); ++_iter36)
+    {
+      xfer += (*_iter36).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
   xfer += oprot->writeFieldEnd();
 
-  if (this->__isset.revokeGrantOption) {
-    xfer += oprot->writeFieldBegin("revokeGrantOption", 
::apache::thrift::protocol::T_BOOL, 3);
-    xfer += oprot->writeBool(this->revokeGrantOption);
-    xfer += oprot->writeFieldEnd();
-  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) {
+void swap(PrivilegeBag &a, PrivilegeBag &b) {
   using ::std::swap;
-  swap(a.requestType, b.requestType);
   swap(a.privileges, b.privileges);
-  swap(a.revokeGrantOption, b.revokeGrantOption);
   swap(a.__isset, b.__isset);
 }
 
-GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const 
GrantRevokePrivilegeRequest& other80) {
-  requestType = other80.requestType;
-  privileges = other80.privileges;
-  revokeGrantOption = other80.revokeGrantOption;
-  __isset = other80.__isset;
+PrivilegeBag::PrivilegeBag(const PrivilegeBag& other37) {
+  privileges = other37.privileges;
+  __isset = other37.__isset;
 }
-GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const 
GrantRevokePrivilegeRequest& other81) {
-  requestType = other81.requestType;
-  privileges = other81.privileges;
-  revokeGrantOption = other81.revokeGrantOption;
-  __isset = other81.__isset;
+PrivilegeBag& PrivilegeBag::operator=(const PrivilegeBag& other38) {
+  privileges = other38.privileges;
+  __isset = other38.__isset;
   return *this;
 }
-void GrantRevokePrivilegeRequest::printTo(std::ostream& out) const {
+void PrivilegeBag::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "GrantRevokePrivilegeRequest(";
-  out << "requestType=" << to_string(requestType);
-  out << ", " << "privileges=" << to_string(privileges);
-  out << ", " << "revokeGrantOption="; (__isset.revokeGrantOption ? (out << 
to_string(revokeGrantOption)) : (out << "<null>"));
+  out << "PrivilegeBag(";
+  out << "privileges=" << to_string(privileges);
   out << ")";
 }
 
 
-GrantRevokePrivilegeResponse::~GrantRevokePrivilegeResponse() throw() {
+PrincipalPrivilegeSet::~PrincipalPrivilegeSet() throw() {
 }
 
 
-void GrantRevokePrivilegeResponse::__set_success(const bool val) {
-  this->success = val;
-__isset.success = true;
+void PrincipalPrivilegeSet::__set_userPrivileges(const std::map<std::string, 
std::vector<PrivilegeGrantInfo> > & val) {
+  this->userPrivileges = val;
 }
 
-uint32_t 
GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+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;
+}
+
+uint32_t PrincipalPrivilegeSet::read(::apache::thrift::protocol::TProtocol* 
iprot) {
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -1593,9 +1784,106 @@ uint32_t 
GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtoco
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->success);
-          this->__isset.success = true;
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->userPrivileges.clear();
+            uint32_t _size39;
+            ::apache::thrift::protocol::TType _ktype40;
+            ::apache::thrift::protocol::TType _vtype41;
+            xfer += iprot->readMapBegin(_ktype40, _vtype41, _size39);
+            uint32_t _i43;
+            for (_i43 = 0; _i43 < _size39; ++_i43)
+            {
+              std::string _key44;
+              xfer += iprot->readString(_key44);
+              std::vector<PrivilegeGrantInfo> & _val45 = 
this->userPrivileges[_key44];
+              {
+                _val45.clear();
+                uint32_t _size46;
+                ::apache::thrift::protocol::TType _etype49;
+                xfer += iprot->readListBegin(_etype49, _size46);
+                _val45.resize(_size46);
+                uint32_t _i50;
+                for (_i50 = 0; _i50 < _size46; ++_i50)
+                {
+                  xfer += _val45[_i50].read(iprot);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.userPrivileges = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->groupPrivileges.clear();
+            uint32_t _size51;
+            ::apache::thrift::protocol::TType _ktype52;
+            ::apache::thrift::protocol::TType _vtype53;
+            xfer += iprot->readMapBegin(_ktype52, _vtype53, _size51);
+            uint32_t _i55;
+            for (_i55 = 0; _i55 < _size51; ++_i55)
+            {
+              std::string _key56;
+              xfer += iprot->readString(_key56);
+              std::vector<PrivilegeGrantInfo> & _val57 = 
this->groupPrivileges[_key56];
+              {
+                _val57.clear();
+                uint32_t _size58;
+                ::apache::thrift::protocol::TType _etype61;
+                xfer += iprot->readListBegin(_etype61, _size58);
+                _val57.resize(_size58);
+                uint32_t _i62;
+                for (_i62 = 0; _i62 < _size58; ++_i62)
+                {
+                  xfer += _val57[_i62].read(iprot);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.groupPrivileges = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_MAP) {
+          {
+            this->rolePrivileges.clear();
+            uint32_t _size63;
+            ::apache::thrift::protocol::TType _ktype64;
+            ::apache::thrift::protocol::TType _vtype65;
+            xfer += iprot->readMapBegin(_ktype64, _vtype65, _size63);
+            uint32_t _i67;
+            for (_i67 = 0; _i67 < _size63; ++_i67)
+            {
+              std::string _key68;
+              xfer += iprot->readString(_key68);
+              std::vector<PrivilegeGrantInfo> & _val69 = 
this->rolePrivileges[_key68];
+              {
+                _val69.clear();
+                uint32_t _size70;
+                ::apache::thrift::protocol::TType _etype73;
+                xfer += iprot->readListBegin(_etype73, _size70);
+                _val69.resize(_size70);
+                uint32_t _i74;
+                for (_i74 = 0; _i74 < _size70; ++_i74)
+                {
+                  xfer += _val69[_i74].read(iprot);
+                }
+                xfer += iprot->readListEnd();
+              }
+            }
+            xfer += iprot->readMapEnd();
+          }
+          this->__isset.rolePrivileges = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -1612,61 +1900,128 @@ uint32_t 
GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtoco
   return xfer;
 }
 
-uint32_t 
GrantRevokePrivilegeResponse::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+uint32_t PrincipalPrivilegeSet::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("GrantRevokePrivilegeResponse");
+  xfer += oprot->writeStructBegin("PrincipalPrivilegeSet");
 
-  if (this->__isset.success) {
-    xfer += oprot->writeFieldBegin("success", 
::apache::thrift::protocol::T_BOOL, 1);
-    xfer += oprot->writeBool(this->success);
-    xfer += oprot->writeFieldEnd();
+  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 
_iter75;
+    for (_iter75 = this->userPrivileges.begin(); _iter75 != 
this->userPrivileges.end(); ++_iter75)
+    {
+      xfer += oprot->writeString(_iter75->first);
+      {
+        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 += (*_iter76).write(oprot);
+        }
+        xfer += oprot->writeListEnd();
+      }
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  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 
_iter77;
+    for (_iter77 = this->groupPrivileges.begin(); _iter77 != 
this->groupPrivileges.end(); ++_iter77)
+    {
+      xfer += oprot->writeString(_iter77->first);
+      {
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(_iter77->second.size()));
+        std::vector<PrivilegeGrantInfo> ::const_iterator _iter78;
+        for (_iter78 = _iter77->second.begin(); _iter78 != 
_iter77->second.end(); ++_iter78)
+        {
+          xfer += (*_iter78).write(oprot);
+        }
+        xfer += oprot->writeListEnd();
+      }
+    }
+    xfer += oprot->writeMapEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  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 
_iter79;
+    for (_iter79 = this->rolePrivileges.begin(); _iter79 != 
this->rolePrivileges.end(); ++_iter79)
+    {
+      xfer += oprot->writeString(_iter79->first);
+      {
+        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, 
static_cast<uint32_t>(_iter79->second.size()));
+        std::vector<PrivilegeGrantInfo> ::const_iterator _iter80;
+        for (_iter80 = _iter79->second.begin(); _iter80 != 
_iter79->second.end(); ++_iter80)
+        {
+          xfer += (*_iter80).write(oprot);
+        }
+        xfer += oprot->writeListEnd();
+      }
+    }
+    xfer += oprot->writeMapEnd();
   }
+  xfer += oprot->writeFieldEnd();
+
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
 }
 
-void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) {
+void swap(PrincipalPrivilegeSet &a, PrincipalPrivilegeSet &b) {
   using ::std::swap;
-  swap(a.success, b.success);
+  swap(a.userPrivileges, b.userPrivileges);
+  swap(a.groupPrivileges, b.groupPrivileges);
+  swap(a.rolePrivileges, b.rolePrivileges);
   swap(a.__isset, b.__isset);
 }
 
-GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const 
GrantRevokePrivilegeResponse& other82) {
-  success = other82.success;
-  __isset = other82.__isset;
+PrincipalPrivilegeSet::PrincipalPrivilegeSet(const PrincipalPrivilegeSet& 
other81) {
+  userPrivileges = other81.userPrivileges;
+  groupPrivileges = other81.groupPrivileges;
+  rolePrivileges = other81.rolePrivileges;
+  __isset = other81.__isset;
 }
-GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const 
GrantRevokePrivilegeResponse& other83) {
-  success = other83.success;
-  __isset = other83.__isset;
+PrincipalPrivilegeSet& PrincipalPrivilegeSet::operator=(const 
PrincipalPrivilegeSet& other82) {
+  userPrivileges = other82.userPrivileges;
+  groupPrivileges = other82.groupPrivileges;
+  rolePrivileges = other82.rolePrivileges;
+  __isset = other82.__isset;
   return *this;
 }
-void GrantRevokePrivilegeResponse::printTo(std::ostream& out) const {
+void PrincipalPrivilegeSet::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "GrantRevokePrivilegeResponse(";
-  out << "success="; (__isset.success ? (out << to_string(success)) : (out << 
"<null>"));
+  out << "PrincipalPrivilegeSet(";
+  out << "userPrivileges=" << to_string(userPrivileges);
+  out << ", " << "groupPrivileges=" << to_string(groupPrivileges);
+  out << ", " << "rolePrivileges=" << to_string(rolePrivileges);
   out << ")";
 }
 
 
-Role::~Role() throw() {
+GrantRevokePrivilegeRequest::~GrantRevokePrivilegeRequest() throw() {
 }
 
 
-void Role::__set_roleName(const std::string& val) {
-  this->roleName = val;
+void GrantRevokePrivilegeRequest::__set_requestType(const 
GrantRevokeType::type val) {
+  this->requestType = val;
 }
 
-void Role::__set_createTime(const int32_t val) {
-  this->createTime = val;
+void GrantRevokePrivilegeRequest::__set_privileges(const PrivilegeBag& val) {
+  this->privileges = val;
 }
 
-void Role::__set_ownerName(const std::string& val) {
-  this->ownerName = val;
+void GrantRevokePrivilegeRequest::__set_revokeGrantOption(const bool val) {
+  this->revokeGrantOption = val;
+__isset.revokeGrantOption = true;
 }
 
-uint32_t Role::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t 
GrantRevokePrivilegeRequest::read(::apache::thrift::protocol::TProtocol* iprot) 
{
 
   apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -1688,25 +2043,27 @@ uint32_t 
Role::read(::apache::thrift::protocol::TProtocol* iprot) {
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->roleName);
-          this->__isset.roleName = true;
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast83;
+          xfer += iprot->readI32(ecast83);
+          this->requestType = (GrantRevokeType::type)ecast83;
+          this->__isset.requestType = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->createTime);
-          this->__isset.createTime = true;
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->privileges.read(iprot);
+          this->__isset.privileges = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->ownerName);
-          this->__isset.ownerName = true;
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->revokeGrantOption);
+          this->__isset.revokeGrantOption = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -1723,14 +2080,229 @@ uint32_t 
Role::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t 
GrantRevokePrivilegeRequest::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
   uint32_t xfer = 0;
   apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("Role");
+  xfer += oprot->writeStructBegin("GrantRevokePrivilegeRequest");
 
-  xfer += oprot->writeFieldBegin("roleName", 
::apache::thrift::protocol::T_STRING, 1);
-  xfer += oprot->writeString(this->roleName);
-  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("requestType", 
::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->requestType);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("privileges", 
::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->privileges.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.revokeGrantOption) {
+    xfer += oprot->writeFieldBegin("revokeGrantOption", 
::apache::thrift::protocol::T_BOOL, 3);
+    xfer += oprot->writeBool(this->revokeGrantOption);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GrantRevokePrivilegeRequest &a, GrantRevokePrivilegeRequest &b) {
+  using ::std::swap;
+  swap(a.requestType, b.requestType);
+  swap(a.privileges, b.privileges);
+  swap(a.revokeGrantOption, b.revokeGrantOption);
+  swap(a.__isset, b.__isset);
+}
+
+GrantRevokePrivilegeRequest::GrantRevokePrivilegeRequest(const 
GrantRevokePrivilegeRequest& other84) {
+  requestType = other84.requestType;
+  privileges = other84.privileges;
+  revokeGrantOption = other84.revokeGrantOption;
+  __isset = other84.__isset;
+}
+GrantRevokePrivilegeRequest& GrantRevokePrivilegeRequest::operator=(const 
GrantRevokePrivilegeRequest& other85) {
+  requestType = other85.requestType;
+  privileges = other85.privileges;
+  revokeGrantOption = other85.revokeGrantOption;
+  __isset = other85.__isset;
+  return *this;
+}
+void GrantRevokePrivilegeRequest::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "GrantRevokePrivilegeRequest(";
+  out << "requestType=" << to_string(requestType);
+  out << ", " << "privileges=" << to_string(privileges);
+  out << ", " << "revokeGrantOption="; (__isset.revokeGrantOption ? (out << 
to_string(revokeGrantOption)) : (out << "<null>"));
+  out << ")";
+}
+
+
+GrantRevokePrivilegeResponse::~GrantRevokePrivilegeResponse() throw() {
+}
+
+
+void GrantRevokePrivilegeResponse::__set_success(const bool val) {
+  this->success = val;
+__isset.success = true;
+}
+
+uint32_t 
GrantRevokePrivilegeResponse::read(::apache::thrift::protocol::TProtocol* 
iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t 
GrantRevokePrivilegeResponse::write(::apache::thrift::protocol::TProtocol* 
oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("GrantRevokePrivilegeResponse");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", 
::apache::thrift::protocol::T_BOOL, 1);
+    xfer += oprot->writeBool(this->success);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(GrantRevokePrivilegeResponse &a, GrantRevokePrivilegeResponse &b) {
+  using ::std::swap;
+  swap(a.success, b.success);
+  swap(a.__isset, b.__isset);
+}
+
+GrantRevokePrivilegeResponse::GrantRevokePrivilegeResponse(const 
GrantRevokePrivilegeResponse& other86) {
+  success = other86.success;
+  __isset = other86.__isset;
+}
+GrantRevokePrivilegeResponse& GrantRevokePrivilegeResponse::operator=(const 
GrantRevokePrivilegeResponse& other87) {
+  success = other87.success;
+  __isset = other87.__isset;
+  return *this;
+}
+void GrantRevokePrivilegeResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "GrantRevokePrivilegeResponse(";
+  out << "success="; (__isset.success ? (out << to_string(success)) : (out << 
"<null>"));
+  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;
+}
+
+uint32_t Role::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->roleName);
+          this->__isset.roleName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->createTime);
+          this->__isset.createTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->ownerName);
+          this->__isset.ownerName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Role::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Role");
+
+  xfer += oprot->writeFieldBegin("roleName", 
::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->roleName);
+  xfer += oprot->writeFieldEnd();
 
   xfer += oprot->writeFieldBegin("createTime", 
::apache::thrift::protocol::T_I32, 2);
   xfer += oprot->writeI32(this->createTime);
@@ -1753,17 +2325,17 @@ 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(const Role& other88) {
+  roleName = other88.roleName;
+  createTime = other88.createTime;
+  ownerName = other88.ownerName;
+  __isset = other88.__isset;
 }
-Role& Role::operator=(const Role& other85) {
-  roleName = other85.roleName;
-  createTime = other85.createTime;
-  ownerName = other85.ownerName;
-  __isset = other85.__isset;
+Role& Role::operator=(const Role& other89) {
+  roleName = other89.roleName;
+  createTime = other89.createTime;
+  ownerName = other89.ownerName;
+  __isset = other89.__isset;
   return *this;
 }
 void Role::printTo(std::ostream& out) const {
@@ -1847,9 +2419,9 @@ uint32_t 
RolePrincipalGrant::read(::apache::thrift::protocol::TProtocol* iprot)
         break;
  

<TRUNCATED>