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>