http://git-wip-us.apache.org/repos/asf/hive/blob/ba8a99e1/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp index 8e357f6..987a4f3 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp @@ -544,6 +544,11 @@ void SQLPrimaryKey::__set_rely_cstr(const bool val) { this->rely_cstr = val; } +void SQLPrimaryKey::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + uint32_t SQLPrimaryKey::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -629,6 +634,14 @@ uint32_t SQLPrimaryKey::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 9: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -678,6 +691,11 @@ uint32_t SQLPrimaryKey::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 9); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -693,6 +711,7 @@ void swap(SQLPrimaryKey &a, SQLPrimaryKey &b) { swap(a.enable_cstr, b.enable_cstr); swap(a.validate_cstr, b.validate_cstr); swap(a.rely_cstr, b.rely_cstr); + swap(a.catName, b.catName); swap(a.__isset, b.__isset); } @@ -705,6 +724,7 @@ SQLPrimaryKey::SQLPrimaryKey(const SQLPrimaryKey& other4) { enable_cstr = other4.enable_cstr; validate_cstr = other4.validate_cstr; rely_cstr = other4.rely_cstr; + catName = other4.catName; __isset = other4.__isset; } SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other5) { @@ -716,6 +736,7 @@ SQLPrimaryKey& SQLPrimaryKey::operator=(const SQLPrimaryKey& other5) { enable_cstr = other5.enable_cstr; validate_cstr = other5.validate_cstr; rely_cstr = other5.rely_cstr; + catName = other5.catName; __isset = other5.__isset; return *this; } @@ -730,6 +751,7 @@ void SQLPrimaryKey::printTo(std::ostream& out) const { out << ", " << "enable_cstr=" << to_string(enable_cstr); out << ", " << "validate_cstr=" << to_string(validate_cstr); out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); out << ")"; } @@ -794,6 +816,11 @@ void SQLForeignKey::__set_rely_cstr(const bool val) { this->rely_cstr = val; } +void SQLForeignKey::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + uint32_t SQLForeignKey::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -927,6 +954,14 @@ uint32_t SQLForeignKey::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 15: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -1000,6 +1035,11 @@ uint32_t SQLForeignKey::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 15); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -1021,6 +1061,7 @@ void swap(SQLForeignKey &a, SQLForeignKey &b) { swap(a.enable_cstr, b.enable_cstr); swap(a.validate_cstr, b.validate_cstr); swap(a.rely_cstr, b.rely_cstr); + swap(a.catName, b.catName); swap(a.__isset, b.__isset); } @@ -1039,6 +1080,7 @@ SQLForeignKey::SQLForeignKey(const SQLForeignKey& other6) { enable_cstr = other6.enable_cstr; validate_cstr = other6.validate_cstr; rely_cstr = other6.rely_cstr; + catName = other6.catName; __isset = other6.__isset; } SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other7) { @@ -1056,6 +1098,7 @@ SQLForeignKey& SQLForeignKey::operator=(const SQLForeignKey& other7) { enable_cstr = other7.enable_cstr; validate_cstr = other7.validate_cstr; rely_cstr = other7.rely_cstr; + catName = other7.catName; __isset = other7.__isset; return *this; } @@ -1076,6 +1119,7 @@ void SQLForeignKey::printTo(std::ostream& out) const { out << ", " << "enable_cstr=" << to_string(enable_cstr); out << ", " << "validate_cstr=" << to_string(validate_cstr); out << ", " << "rely_cstr=" << to_string(rely_cstr); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); out << ")"; } @@ -1084,6 +1128,10 @@ SQLUniqueConstraint::~SQLUniqueConstraint() throw() { } +void SQLUniqueConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + void SQLUniqueConstraint::__set_table_db(const std::string& val) { this->table_db = val; } @@ -1139,13 +1187,21 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_db); this->__isset.table_db = true; } else { xfer += iprot->skip(ftype); } break; - case 2: + case 3: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_name); this->__isset.table_name = true; @@ -1153,7 +1209,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 3: + case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->column_name); this->__isset.column_name = true; @@ -1161,7 +1217,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 4: + case 5: if (ftype == ::apache::thrift::protocol::T_I32) { xfer += iprot->readI32(this->key_seq); this->__isset.key_seq = true; @@ -1169,7 +1225,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 5: + case 6: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->uk_name); this->__isset.uk_name = true; @@ -1177,7 +1233,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 6: + case 7: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->enable_cstr); this->__isset.enable_cstr = true; @@ -1185,7 +1241,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 7: + case 8: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->validate_cstr); this->__isset.validate_cstr = true; @@ -1193,7 +1249,7 @@ uint32_t SQLUniqueConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 8: + case 9: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->rely_cstr); this->__isset.rely_cstr = true; @@ -1218,35 +1274,39 @@ uint32_t SQLUniqueConstraint::write(::apache::thrift::protocol::TProtocol* oprot apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("SQLUniqueConstraint"); - xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); xfer += oprot->writeString(this->table_db); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); xfer += oprot->writeString(this->table_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); xfer += oprot->writeString(this->column_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 4); + xfer += oprot->writeFieldBegin("key_seq", ::apache::thrift::protocol::T_I32, 5); xfer += oprot->writeI32(this->key_seq); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("uk_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeFieldBegin("uk_name", ::apache::thrift::protocol::T_STRING, 6); xfer += oprot->writeString(this->uk_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); xfer += oprot->writeBool(this->enable_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); xfer += oprot->writeBool(this->validate_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); @@ -1257,6 +1317,7 @@ uint32_t SQLUniqueConstraint::write(::apache::thrift::protocol::TProtocol* oprot void swap(SQLUniqueConstraint &a, SQLUniqueConstraint &b) { using ::std::swap; + swap(a.catName, b.catName); swap(a.table_db, b.table_db); swap(a.table_name, b.table_name); swap(a.column_name, b.column_name); @@ -1269,6 +1330,7 @@ void swap(SQLUniqueConstraint &a, SQLUniqueConstraint &b) { } SQLUniqueConstraint::SQLUniqueConstraint(const SQLUniqueConstraint& other8) { + catName = other8.catName; table_db = other8.table_db; table_name = other8.table_name; column_name = other8.column_name; @@ -1280,6 +1342,7 @@ SQLUniqueConstraint::SQLUniqueConstraint(const SQLUniqueConstraint& other8) { __isset = other8.__isset; } SQLUniqueConstraint& SQLUniqueConstraint::operator=(const SQLUniqueConstraint& other9) { + catName = other9.catName; table_db = other9.table_db; table_name = other9.table_name; column_name = other9.column_name; @@ -1294,7 +1357,8 @@ SQLUniqueConstraint& SQLUniqueConstraint::operator=(const SQLUniqueConstraint& o void SQLUniqueConstraint::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "SQLUniqueConstraint("; - out << "table_db=" << to_string(table_db); + out << "catName=" << to_string(catName); + 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); @@ -1310,6 +1374,10 @@ SQLNotNullConstraint::~SQLNotNullConstraint() throw() { } +void SQLNotNullConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + void SQLNotNullConstraint::__set_table_db(const std::string& val) { this->table_db = val; } @@ -1361,13 +1429,21 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_db); this->__isset.table_db = true; } else { xfer += iprot->skip(ftype); } break; - case 2: + case 3: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_name); this->__isset.table_name = true; @@ -1375,7 +1451,7 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 3: + case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->column_name); this->__isset.column_name = true; @@ -1383,7 +1459,7 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 4: + case 5: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->nn_name); this->__isset.nn_name = true; @@ -1391,7 +1467,7 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 5: + case 6: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->enable_cstr); this->__isset.enable_cstr = true; @@ -1399,7 +1475,7 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 6: + case 7: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->validate_cstr); this->__isset.validate_cstr = true; @@ -1407,7 +1483,7 @@ uint32_t SQLNotNullConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 7: + case 8: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->rely_cstr); this->__isset.rely_cstr = true; @@ -1432,31 +1508,35 @@ uint32_t SQLNotNullConstraint::write(::apache::thrift::protocol::TProtocol* opro apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("SQLNotNullConstraint"); - xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); xfer += oprot->writeString(this->table_db); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); xfer += oprot->writeString(this->table_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); xfer += oprot->writeString(this->column_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("nn_name", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeFieldBegin("nn_name", ::apache::thrift::protocol::T_STRING, 5); xfer += oprot->writeString(this->nn_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 5); + 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, 6); + 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, 7); + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); @@ -1467,6 +1547,7 @@ uint32_t SQLNotNullConstraint::write(::apache::thrift::protocol::TProtocol* opro void swap(SQLNotNullConstraint &a, SQLNotNullConstraint &b) { using ::std::swap; + swap(a.catName, b.catName); swap(a.table_db, b.table_db); swap(a.table_name, b.table_name); swap(a.column_name, b.column_name); @@ -1478,6 +1559,7 @@ void swap(SQLNotNullConstraint &a, SQLNotNullConstraint &b) { } SQLNotNullConstraint::SQLNotNullConstraint(const SQLNotNullConstraint& other10) { + catName = other10.catName; table_db = other10.table_db; table_name = other10.table_name; column_name = other10.column_name; @@ -1488,6 +1570,7 @@ SQLNotNullConstraint::SQLNotNullConstraint(const SQLNotNullConstraint& other10) __isset = other10.__isset; } SQLNotNullConstraint& SQLNotNullConstraint::operator=(const SQLNotNullConstraint& other11) { + catName = other11.catName; table_db = other11.table_db; table_name = other11.table_name; column_name = other11.column_name; @@ -1501,7 +1584,8 @@ SQLNotNullConstraint& SQLNotNullConstraint::operator=(const SQLNotNullConstraint void SQLNotNullConstraint::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "SQLNotNullConstraint("; - out << "table_db=" << to_string(table_db); + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); out << ", " << "table_name=" << to_string(table_name); out << ", " << "column_name=" << to_string(column_name); out << ", " << "nn_name=" << to_string(nn_name); @@ -1516,6 +1600,10 @@ SQLDefaultConstraint::~SQLDefaultConstraint() throw() { } +void SQLDefaultConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + void SQLDefaultConstraint::__set_table_db(const std::string& val) { this->table_db = val; } @@ -1571,13 +1659,21 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_db); this->__isset.table_db = true; } else { xfer += iprot->skip(ftype); } break; - case 2: + case 3: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_name); this->__isset.table_name = true; @@ -1585,7 +1681,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 3: + case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->column_name); this->__isset.column_name = true; @@ -1593,7 +1689,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 4: + case 5: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->default_value); this->__isset.default_value = true; @@ -1601,7 +1697,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 5: + case 6: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->dc_name); this->__isset.dc_name = true; @@ -1609,7 +1705,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 6: + case 7: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->enable_cstr); this->__isset.enable_cstr = true; @@ -1617,7 +1713,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 7: + case 8: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->validate_cstr); this->__isset.validate_cstr = true; @@ -1625,7 +1721,7 @@ uint32_t SQLDefaultConstraint::read(::apache::thrift::protocol::TProtocol* iprot xfer += iprot->skip(ftype); } break; - case 8: + case 9: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->rely_cstr); this->__isset.rely_cstr = true; @@ -1650,35 +1746,39 @@ uint32_t SQLDefaultConstraint::write(::apache::thrift::protocol::TProtocol* opro apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("SQLDefaultConstraint"); - xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); xfer += oprot->writeString(this->table_db); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); xfer += oprot->writeString(this->table_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); xfer += oprot->writeString(this->column_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("default_value", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeFieldBegin("default_value", ::apache::thrift::protocol::T_STRING, 5); xfer += oprot->writeString(this->default_value); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 6); xfer += oprot->writeString(this->dc_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); xfer += oprot->writeBool(this->enable_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); xfer += oprot->writeBool(this->validate_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); @@ -1689,6 +1789,7 @@ uint32_t SQLDefaultConstraint::write(::apache::thrift::protocol::TProtocol* opro void swap(SQLDefaultConstraint &a, SQLDefaultConstraint &b) { using ::std::swap; + swap(a.catName, b.catName); swap(a.table_db, b.table_db); swap(a.table_name, b.table_name); swap(a.column_name, b.column_name); @@ -1701,6 +1802,7 @@ void swap(SQLDefaultConstraint &a, SQLDefaultConstraint &b) { } SQLDefaultConstraint::SQLDefaultConstraint(const SQLDefaultConstraint& other12) { + catName = other12.catName; table_db = other12.table_db; table_name = other12.table_name; column_name = other12.column_name; @@ -1712,6 +1814,7 @@ SQLDefaultConstraint::SQLDefaultConstraint(const SQLDefaultConstraint& other12) __isset = other12.__isset; } SQLDefaultConstraint& SQLDefaultConstraint::operator=(const SQLDefaultConstraint& other13) { + catName = other13.catName; table_db = other13.table_db; table_name = other13.table_name; column_name = other13.column_name; @@ -1726,7 +1829,8 @@ SQLDefaultConstraint& SQLDefaultConstraint::operator=(const SQLDefaultConstraint void SQLDefaultConstraint::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "SQLDefaultConstraint("; - out << "table_db=" << to_string(table_db); + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); out << ", " << "table_name=" << to_string(table_name); out << ", " << "column_name=" << to_string(column_name); out << ", " << "default_value=" << to_string(default_value); @@ -1742,6 +1846,10 @@ SQLCheckConstraint::~SQLCheckConstraint() throw() { } +void SQLCheckConstraint::__set_catName(const std::string& val) { + this->catName = val; +} + void SQLCheckConstraint::__set_table_db(const std::string& val) { this->table_db = val; } @@ -1797,13 +1905,21 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_db); this->__isset.table_db = true; } else { xfer += iprot->skip(ftype); } break; - case 2: + case 3: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->table_name); this->__isset.table_name = true; @@ -1811,7 +1927,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 3: + case 4: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->column_name); this->__isset.column_name = true; @@ -1819,7 +1935,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 4: + case 5: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->check_expression); this->__isset.check_expression = true; @@ -1827,7 +1943,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 5: + case 6: if (ftype == ::apache::thrift::protocol::T_STRING) { xfer += iprot->readString(this->dc_name); this->__isset.dc_name = true; @@ -1835,7 +1951,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 6: + case 7: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->enable_cstr); this->__isset.enable_cstr = true; @@ -1843,7 +1959,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 7: + case 8: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->validate_cstr); this->__isset.validate_cstr = true; @@ -1851,7 +1967,7 @@ uint32_t SQLCheckConstraint::read(::apache::thrift::protocol::TProtocol* iprot) xfer += iprot->skip(ftype); } break; - case 8: + case 9: if (ftype == ::apache::thrift::protocol::T_BOOL) { xfer += iprot->readBool(this->rely_cstr); this->__isset.rely_cstr = true; @@ -1876,35 +1992,39 @@ uint32_t SQLCheckConstraint::write(::apache::thrift::protocol::TProtocol* oprot) apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("SQLCheckConstraint"); - xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("table_db", ::apache::thrift::protocol::T_STRING, 2); xfer += oprot->writeString(this->table_db); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeFieldBegin("table_name", ::apache::thrift::protocol::T_STRING, 3); xfer += oprot->writeString(this->table_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 4); xfer += oprot->writeString(this->column_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("check_expression", ::apache::thrift::protocol::T_STRING, 4); + xfer += oprot->writeFieldBegin("check_expression", ::apache::thrift::protocol::T_STRING, 5); xfer += oprot->writeString(this->check_expression); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 5); + xfer += oprot->writeFieldBegin("dc_name", ::apache::thrift::protocol::T_STRING, 6); xfer += oprot->writeString(this->dc_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 6); + xfer += oprot->writeFieldBegin("enable_cstr", ::apache::thrift::protocol::T_BOOL, 7); xfer += oprot->writeBool(this->enable_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 7); + xfer += oprot->writeFieldBegin("validate_cstr", ::apache::thrift::protocol::T_BOOL, 8); xfer += oprot->writeBool(this->validate_cstr); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 8); + xfer += oprot->writeFieldBegin("rely_cstr", ::apache::thrift::protocol::T_BOOL, 9); xfer += oprot->writeBool(this->rely_cstr); xfer += oprot->writeFieldEnd(); @@ -1915,6 +2035,7 @@ uint32_t SQLCheckConstraint::write(::apache::thrift::protocol::TProtocol* oprot) void swap(SQLCheckConstraint &a, SQLCheckConstraint &b) { using ::std::swap; + swap(a.catName, b.catName); swap(a.table_db, b.table_db); swap(a.table_name, b.table_name); swap(a.column_name, b.column_name); @@ -1927,6 +2048,7 @@ void swap(SQLCheckConstraint &a, SQLCheckConstraint &b) { } SQLCheckConstraint::SQLCheckConstraint(const SQLCheckConstraint& other14) { + catName = other14.catName; table_db = other14.table_db; table_name = other14.table_name; column_name = other14.column_name; @@ -1938,6 +2060,7 @@ SQLCheckConstraint::SQLCheckConstraint(const SQLCheckConstraint& other14) { __isset = other14.__isset; } SQLCheckConstraint& SQLCheckConstraint::operator=(const SQLCheckConstraint& other15) { + catName = other15.catName; table_db = other15.table_db; table_name = other15.table_name; column_name = other15.column_name; @@ -1952,7 +2075,8 @@ SQLCheckConstraint& SQLCheckConstraint::operator=(const SQLCheckConstraint& othe void SQLCheckConstraint::printTo(std::ostream& out) const { using ::apache::thrift::to_string; out << "SQLCheckConstraint("; - out << "table_db=" << to_string(table_db); + out << "catName=" << to_string(catName); + out << ", " << "table_db=" << to_string(table_db); out << ", " << "table_name=" << to_string(table_name); out << ", " << "column_name=" << to_string(column_name); out << ", " << "check_expression=" << to_string(check_expression); @@ -2160,6 +2284,11 @@ void HiveObjectRef::__set_columnName(const std::string& val) { this->columnName = val; } +void HiveObjectRef::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -2235,6 +2364,14 @@ uint32_t HiveObjectRef::read(::apache::thrift::protocol::TProtocol* iprot) { xfer += iprot->skip(ftype); } break; + case 6: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catName); + this->__isset.catName = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -2280,6 +2417,11 @@ uint32_t HiveObjectRef::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeString(this->columnName); xfer += oprot->writeFieldEnd(); + if (this->__isset.catName) { + xfer += oprot->writeFieldBegin("catName", ::apache::thrift::protocol::T_STRING, 6); + xfer += oprot->writeString(this->catName); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -2292,6 +2434,7 @@ void swap(HiveObjectRef &a, HiveObjectRef &b) { swap(a.objectName, b.objectName); swap(a.partValues, b.partValues); swap(a.columnName, b.columnName); + swap(a.catName, b.catName); swap(a.__isset, b.__isset); } @@ -2301,6 +2444,7 @@ HiveObjectRef::HiveObjectRef(const HiveObjectRef& other31) { objectName = other31.objectName; partValues = other31.partValues; columnName = other31.columnName; + catName = other31.catName; __isset = other31.__isset; } HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other32) { @@ -2309,6 +2453,7 @@ HiveObjectRef& HiveObjectRef::operator=(const HiveObjectRef& other32) { objectName = other32.objectName; partValues = other32.partValues; columnName = other32.columnName; + catName = other32.catName; __isset = other32.__isset; return *this; } @@ -2320,6 +2465,7 @@ void HiveObjectRef::printTo(std::ostream& out) const { out << ", " << "objectName=" << to_string(objectName); out << ", " << "partValues=" << to_string(partValues); out << ", " << "columnName=" << to_string(columnName); + out << ", " << "catName="; (__isset.catName ? (out << to_string(catName)) : (out << "<null>")); out << ")"; } @@ -4194,7 +4340,586 @@ void GrantRevokeRoleResponse::__set_success(const bool val) { __isset.success = true; } -uint32_t GrantRevokeRoleResponse::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t GrantRevokeRoleResponse::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 GrantRevokeRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GrantRevokeRoleResponse"); + + 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(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) { + using ::std::swap; + swap(a.success, b.success); + swap(a.__isset, b.__isset); +} + +GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other128) { + success = other128.success; + __isset = other128.__isset; +} +GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other129) { + success = other129.success; + __isset = other129.__isset; + return *this; +} +void GrantRevokeRoleResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GrantRevokeRoleResponse("; + out << "success="; (__isset.success ? (out << to_string(success)) : (out << "<null>")); + out << ")"; +} + + +Catalog::~Catalog() throw() { +} + + +void Catalog::__set_name(const std::string& val) { + this->name = val; +} + +void Catalog::__set_description(const std::string& val) { + this->description = val; +__isset.description = true; +} + +void Catalog::__set_locationUri(const std::string& val) { + this->locationUri = val; +} + +uint32_t Catalog::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->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->description); + this->__isset.description = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->locationUri); + this->__isset.locationUri = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t Catalog::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("Catalog"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + if (this->__isset.description) { + xfer += oprot->writeFieldBegin("description", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->description); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldBegin("locationUri", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->locationUri); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(Catalog &a, Catalog &b) { + using ::std::swap; + swap(a.name, b.name); + swap(a.description, b.description); + swap(a.locationUri, b.locationUri); + swap(a.__isset, b.__isset); +} + +Catalog::Catalog(const Catalog& other130) { + name = other130.name; + description = other130.description; + locationUri = other130.locationUri; + __isset = other130.__isset; +} +Catalog& Catalog::operator=(const Catalog& other131) { + name = other131.name; + description = other131.description; + locationUri = other131.locationUri; + __isset = other131.__isset; + return *this; +} +void Catalog::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Catalog("; + out << "name=" << to_string(name); + out << ", " << "description="; (__isset.description ? (out << to_string(description)) : (out << "<null>")); + out << ", " << "locationUri=" << to_string(locationUri); + out << ")"; +} + + +CreateCatalogRequest::~CreateCatalogRequest() throw() { +} + + +void CreateCatalogRequest::__set_catalog(const Catalog& val) { + this->catalog = val; +} + +uint32_t CreateCatalogRequest::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_STRUCT) { + xfer += this->catalog.read(iprot); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t CreateCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("CreateCatalogRequest"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catalog.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(CreateCatalogRequest &a, CreateCatalogRequest &b) { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.__isset, b.__isset); +} + +CreateCatalogRequest::CreateCatalogRequest(const CreateCatalogRequest& other132) { + catalog = other132.catalog; + __isset = other132.__isset; +} +CreateCatalogRequest& CreateCatalogRequest::operator=(const CreateCatalogRequest& other133) { + catalog = other133.catalog; + __isset = other133.__isset; + return *this; +} +void CreateCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CreateCatalogRequest("; + out << "catalog=" << to_string(catalog); + out << ")"; +} + + +GetCatalogRequest::~GetCatalogRequest() throw() { +} + + +void GetCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} + +uint32_t GetCatalogRequest::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->name); + this->__isset.name = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogRequest &a, GetCatalogRequest &b) { + using ::std::swap; + swap(a.name, b.name); + swap(a.__isset, b.__isset); +} + +GetCatalogRequest::GetCatalogRequest(const GetCatalogRequest& other134) { + name = other134.name; + __isset = other134.__isset; +} +GetCatalogRequest& GetCatalogRequest::operator=(const GetCatalogRequest& other135) { + name = other135.name; + __isset = other135.__isset; + return *this; +} +void GetCatalogRequest::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogRequest("; + out << "name=" << to_string(name); + out << ")"; +} + + +GetCatalogResponse::~GetCatalogResponse() throw() { +} + + +void GetCatalogResponse::__set_catalog(const Catalog& val) { + this->catalog = val; +} + +uint32_t GetCatalogResponse::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_STRUCT) { + xfer += this->catalog.read(iprot); + this->__isset.catalog = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogResponse"); + + xfer += oprot->writeFieldBegin("catalog", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->catalog.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogResponse &a, GetCatalogResponse &b) { + using ::std::swap; + swap(a.catalog, b.catalog); + swap(a.__isset, b.__isset); +} + +GetCatalogResponse::GetCatalogResponse(const GetCatalogResponse& other136) { + catalog = other136.catalog; + __isset = other136.__isset; +} +GetCatalogResponse& GetCatalogResponse::operator=(const GetCatalogResponse& other137) { + catalog = other137.catalog; + __isset = other137.__isset; + return *this; +} +void GetCatalogResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogResponse("; + out << "catalog=" << to_string(catalog); + out << ")"; +} + + +GetCatalogsResponse::~GetCatalogsResponse() throw() { +} + + +void GetCatalogsResponse::__set_names(const std::vector<std::string> & val) { + this->names = val; +} + +uint32_t GetCatalogsResponse::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_LIST) { + { + this->names.clear(); + uint32_t _size138; + ::apache::thrift::protocol::TType _etype141; + xfer += iprot->readListBegin(_etype141, _size138); + this->names.resize(_size138); + uint32_t _i142; + for (_i142 = 0; _i142 < _size138; ++_i142) + { + xfer += iprot->readString(this->names[_i142]); + } + xfer += iprot->readListEnd(); + } + this->__isset.names = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t GetCatalogsResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("GetCatalogsResponse"); + + xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 1); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size())); + std::vector<std::string> ::const_iterator _iter143; + for (_iter143 = this->names.begin(); _iter143 != this->names.end(); ++_iter143) + { + xfer += oprot->writeString((*_iter143)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + +void swap(GetCatalogsResponse &a, GetCatalogsResponse &b) { + using ::std::swap; + swap(a.names, b.names); + swap(a.__isset, b.__isset); +} + +GetCatalogsResponse::GetCatalogsResponse(const GetCatalogsResponse& other144) { + names = other144.names; + __isset = other144.__isset; +} +GetCatalogsResponse& GetCatalogsResponse::operator=(const GetCatalogsResponse& other145) { + names = other145.names; + __isset = other145.__isset; + return *this; +} +void GetCatalogsResponse::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "GetCatalogsResponse("; + out << "names=" << to_string(names); + out << ")"; +} + + +DropCatalogRequest::~DropCatalogRequest() throw() { +} + + +void DropCatalogRequest::__set_name(const std::string& val) { + this->name = val; +} + +uint32_t DropCatalogRequest::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -4216,9 +4941,9 @@ uint32_t GrantRevokeRoleResponse::read(::apache::thrift::protocol::TProtocol* ip 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_STRING) { + xfer += iprot->readString(this->name); + this->__isset.name = true; } else { xfer += iprot->skip(ftype); } @@ -4235,40 +4960,39 @@ uint32_t GrantRevokeRoleResponse::read(::apache::thrift::protocol::TProtocol* ip return xfer; } -uint32_t GrantRevokeRoleResponse::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t DropCatalogRequest::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("GrantRevokeRoleResponse"); + xfer += oprot->writeStructBegin("DropCatalogRequest"); + + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->name); + xfer += oprot->writeFieldEnd(); - 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(GrantRevokeRoleResponse &a, GrantRevokeRoleResponse &b) { +void swap(DropCatalogRequest &a, DropCatalogRequest &b) { using ::std::swap; - swap(a.success, b.success); + swap(a.name, b.name); swap(a.__isset, b.__isset); } -GrantRevokeRoleResponse::GrantRevokeRoleResponse(const GrantRevokeRoleResponse& other128) { - success = other128.success; - __isset = other128.__isset; +DropCatalogRequest::DropCatalogRequest(const DropCatalogRequest& other146) { + name = other146.name; + __isset = other146.__isset; } -GrantRevokeRoleResponse& GrantRevokeRoleResponse::operator=(const GrantRevokeRoleResponse& other129) { - success = other129.success; - __isset = other129.__isset; +DropCatalogRequest& DropCatalogRequest::operator=(const DropCatalogRequest& other147) { + name = other147.name; + __isset = other147.__isset; return *this; } -void GrantRevokeRoleResponse::printTo(std::ostream& out) const { +void DropCatalogRequest::printTo(std::ostream& out) const { using ::apache::thrift::to_string; - out << "GrantRevokeRoleResponse("; - out << "success="; (__isset.success ? (out << to_string(success)) : (out << "<null>")); + out << "DropCatalogRequest("; + out << "name=" << to_string(name); out << ")"; } @@ -4308,6 +5032,11 @@ void Database::__set_ownerType(const PrincipalType::type val) { __isset.ownerType = true; } +void Database::__set_catalogName(const std::string& val) { + this->catalogName = val; +__isset.catalogName = true; +} + uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -4357,17 +5086,17 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size130; - ::apache::thrift::protocol::TType _ktype131; - ::apache::thrift::protocol::TType _vtype132; - xfer += iprot->readMapBegin(_ktype131, _vtype132, _size130); - uint32_t _i134; - for (_i134 = 0; _i134 < _size130; ++_i134) + uint32_t _size148; + ::apache::thrift::protocol::TType _ktype149; + ::apache::thrift::protocol::TType _vtype150; + xfer += iprot->readMapBegin(_ktype149, _vtype150, _size148); + uint32_t _i152; + for (_i152 = 0; _i152 < _size148; ++_i152) { - std::string _key135; - xfer += iprot->readString(_key135); - std::string& _val136 = this->parameters[_key135]; - xfer += iprot->readString(_val136); + std::string _key153; + xfer += iprot->readString(_key153); + std::string& _val154 = this->parameters[_key153]; + xfer += iprot->readString(_val154); } xfer += iprot->readMapEnd(); } @@ -4394,14 +5123,22 @@ uint32_t Database::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast137; - xfer += iprot->readI32(ecast137); - this->ownerType = (PrincipalType::type)ecast137; + int32_t ecast155; + xfer += iprot->readI32(ecast155); + this->ownerType = (PrincipalType::type)ecast155; this->__isset.ownerType = true; } else { xfer += iprot->skip(ftype); } break; + case 8: + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->catalogName); + this->__isset.catalogName = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4434,11 +5171,11 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 4); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size())); - std::map<std::string, std::string> ::const_iterator _iter138; - for (_iter138 = this->parameters.begin(); _iter138 != this->parameters.end(); ++_iter138) + std::map<std::string, std::string> ::const_iterator _iter156; + for (_iter156 = this->parameters.begin(); _iter156 != this->parameters.end(); ++_iter156) { - xfer += oprot->writeString(_iter138->first); - xfer += oprot->writeString(_iter138->second); + xfer += oprot->writeString(_iter156->first); + xfer += oprot->writeString(_iter156->second); } xfer += oprot->writeMapEnd(); } @@ -4459,6 +5196,11 @@ uint32_t Database::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeI32((int32_t)this->ownerType); xfer += oprot->writeFieldEnd(); } + if (this->__isset.catalogName) { + xfer += oprot->writeFieldBegin("catalogName", ::apache::thrift::protocol::T_STRING, 8); + xfer += oprot->writeString(this->catalogName); + xfer += oprot->writeFieldEnd(); + } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; @@ -4473,28 +5215,31 @@ void swap(Database &a, Database &b) { swap(a.privileges, b.privileges); swap(a.ownerName, b.ownerName); swap(a.ownerType, b.ownerType); + swap(a.catalogName, b.catalogName); swap(a.__isset, b.__isset); } -Database::Database(const Database& other139) { - name = other139.name; - description = other139.description; - locationUri = other139.locationUri; - parameters = other139.parameters; - privileges = other139.privileges; - ownerName = other139.ownerName; - ownerType = other139.ownerType; - __isset = other139.__isset; -} -Database& Database::operator=(const Database& other140) { - name = other140.name; - description = other140.description; - locationUri = other140.locationUri; - parameters = other140.parameters; - privileges = other140.privileges; - ownerName = other140.ownerName; - ownerType = other140.ownerType; - __isset = other140.__isset; +Database::Database(const Database& other157) { + name = other157.name; + description = other157.description; + locationUri = other157.locationUri; + parameters = other157.parameters; + privileges = other157.privileges; + ownerName = other157.ownerName; + ownerType = other157.ownerType; + catalogName = other157.catalogName; + __isset = other157.__isset; +} +Database& Database::operator=(const Database& other158) { + name = other158.name; + description = other158.description; + locationUri = other158.locationUri; + parameters = other158.parameters; + privileges = other158.privileges; + ownerName = other158.ownerName; + ownerType = other158.ownerType; + catalogName = other158.catalogName; + __isset = other158.__isset; return *this; } void Database::printTo(std::ostream& out) const { @@ -4507,6 +5252,7 @@ void Database::printTo(std::ostream& out) const { out << ", " << "privileges="; (__isset.privileges ? (out << to_string(privileges)) : (out << "<null>")); out << ", " << "ownerName="; (__isset.ownerName ? (out << to_string(ownerName)) : (out << "<null>")); out << ", " << "ownerType="; (__isset.ownerType ? (out << to_string(ownerType)) : (out << "<null>")); + out << ", " << "catalogName="; (__isset.catalogName ? (out << to_string(catalogName)) : (out << "<null>")); out << ")"; } @@ -4588,17 +5334,17 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size141; - ::apache::thrift::protocol::TType _ktype142; - ::apache::thrift::protocol::TType _vtype143; - xfer += iprot->readMapBegin(_ktype142, _vtype143, _size141); - uint32_t _i145; - for (_i145 = 0; _i145 < _size141; ++_i145) + uint32_t _size159; + ::apache::thrift::protocol::TType _ktype160; + ::apache::thrift::protocol::TType _vtype161; + xfer += iprot->readMapBegin(_ktype160, _vtype161, _size159); + uint32_t _i163; + for (_i163 = 0; _i163 < _size159; ++_i163) { - std::string _key146; - xfer += iprot->readString(_key146); - std::string& _val147 = this->parameters[_key146]; - xfer += iprot->readString(_val147); + std::string _key164; + xfer += iprot->readString(_key164); + std::string& _val165 = this->parameters[_key164]; + xfer += iprot->readString(_val165); } xfer += iprot->readMapEnd(); } @@ -4633,9 +5379,9 @@ uint32_t SerDeInfo::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast148; - xfer += iprot->readI32(ecast148); - this->serdeType = (SerdeType::type)ecast148; + int32_t ecast166; + xfer += iprot->readI32(ecast166); + this->serdeType = (SerdeType::type)ecast166; this->__isset.serdeType = true; } else { xfer += iprot->skip(ftype); @@ -4669,11 +5415,11 @@ uint32_t SerDeInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size())); - std::map<std::string, std::string> ::const_iterator _iter149; - for (_iter149 = this->parameters.begin(); _iter149 != this->parameters.end(); ++_iter149) + std::map<std::string, std::string> ::const_iterator _iter167; + for (_iter167 = this->parameters.begin(); _iter167 != this->parameters.end(); ++_iter167) { - xfer += oprot->writeString(_iter149->first); - xfer += oprot->writeString(_iter149->second); + xfer += oprot->writeString(_iter167->first); + xfer += oprot->writeString(_iter167->second); } xfer += oprot->writeMapEnd(); } @@ -4716,25 +5462,25 @@ void swap(SerDeInfo &a, SerDeInfo &b) { swap(a.__isset, b.__isset); } -SerDeInfo::SerDeInfo(const SerDeInfo& other150) { - name = other150.name; - serializationLib = other150.serializationLib; - parameters = other150.parameters; - description = other150.description; - serializerClass = other150.serializerClass; - deserializerClass = other150.deserializerClass; - serdeType = other150.serdeType; - __isset = other150.__isset; -} -SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other151) { - name = other151.name; - serializationLib = other151.serializationLib; - parameters = other151.parameters; - description = other151.description; - serializerClass = other151.serializerClass; - deserializerClass = other151.deserializerClass; - serdeType = other151.serdeType; - __isset = other151.__isset; +SerDeInfo::SerDeInfo(const SerDeInfo& other168) { + name = other168.name; + serializationLib = other168.serializationLib; + parameters = other168.parameters; + description = other168.description; + serializerClass = other168.serializerClass; + deserializerClass = other168.deserializerClass; + serdeType = other168.serdeType; + __isset = other168.__isset; +} +SerDeInfo& SerDeInfo::operator=(const SerDeInfo& other169) { + name = other169.name; + serializationLib = other169.serializationLib; + parameters = other169.parameters; + description = other169.description; + serializerClass = other169.serializerClass; + deserializerClass = other169.deserializerClass; + serdeType = other169.serdeType; + __isset = other169.__isset; return *this; } void SerDeInfo::printTo(std::ostream& out) const { @@ -4837,15 +5583,15 @@ void swap(Order &a, Order &b) { swap(a.__isset, b.__isset); } -Order::Order(const Order& other152) { - col = other152.col; - order = other152.order; - __isset = other152.__isset; +Order::Order(const Order& other170) { + col = other170.col; + order = other170.order; + __isset = other170.__isset; } -Order& Order::operator=(const Order& other153) { - col = other153.col; - order = other153.order; - __isset = other153.__isset; +Order& Order::operator=(const Order& other171) { + col = other171.col; + order = other171.order; + __isset = other171.__isset; return *this; } void Order::printTo(std::ostream& out) const { @@ -4898,14 +5644,14 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColNames.clear(); - uint32_t _size154; - ::apache::thrift::protocol::TType _etype157; - xfer += iprot->readListBegin(_etype157, _size154); - this->skewedColNames.resize(_size154); - uint32_t _i158; - for (_i158 = 0; _i158 < _size154; ++_i158) + uint32_t _size172; + ::apache::thrift::protocol::TType _etype175; + xfer += iprot->readListBegin(_etype175, _size172); + this->skewedColNames.resize(_size172); + uint32_t _i176; + for (_i176 = 0; _i176 < _size172; ++_i176) { - xfer += iprot->readString(this->skewedColNames[_i158]); + xfer += iprot->readString(this->skewedColNames[_i176]); } xfer += iprot->readListEnd(); } @@ -4918,23 +5664,23 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->skewedColValues.clear(); - uint32_t _size159; - ::apache::thrift::protocol::TType _etype162; - xfer += iprot->readListBegin(_etype162, _size159); - this->skewedColValues.resize(_size159); - uint32_t _i163; - for (_i163 = 0; _i163 < _size159; ++_i163) + uint32_t _size177; + ::apache::thrift::protocol::TType _etype180; + xfer += iprot->readListBegin(_etype180, _size177); + this->skewedColValues.resize(_size177); + uint32_t _i181; + for (_i181 = 0; _i181 < _size177; ++_i181) { { - this->skewedColValues[_i163].clear(); - uint32_t _size164; - ::apache::thrift::protocol::TType _etype167; - xfer += iprot->readListBegin(_etype167, _size164); - this->skewedColValues[_i163].resize(_size164); - uint32_t _i168; - for (_i168 = 0; _i168 < _size164; ++_i168) + this->skewedColValues[_i181].clear(); + uint32_t _size182; + ::apache::thrift::protocol::TType _etype185; + xfer += iprot->readListBegin(_etype185, _size182); + this->skewedColValues[_i181].resize(_size182); + uint32_t _i186; + for (_i186 = 0; _i186 < _size182; ++_i186) { - xfer += iprot->readString(this->skewedColValues[_i163][_i168]); + xfer += iprot->readString(this->skewedColValues[_i181][_i186]); } xfer += iprot->readListEnd(); } @@ -4950,29 +5696,29 @@ uint32_t SkewedInfo::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->skewedColValueLocationMaps.clear(); - uint32_t _size169; - ::apache::thrift::protocol::TType _ktype170; - ::apache::thrift::protocol::TType _vtype171; - xfer += iprot->readMapBegin(_ktype170, _vtype171, _size169); - uint32_t _i173; - for (_i173 = 0; _i173 < _size169; ++_i173) + uint32_t _size187; + ::apache::thrift::protocol::TType _ktype188; + ::apache::thrift::protocol::TType _vtype189; + xfer += iprot->readMapBegin(_ktype188, _vtype189, _size187); + uint32_t _i191; + for (_i191 = 0; _i191 < _size187; ++_i191) { - std::vector<std::string> _key174; + std::vector<std::string> _key192; { - _key174.clear(); - uint32_t _size176; - ::apache::thrift::protocol::TType _etype179; - xfer += iprot->readListBegin(_etype179, _size176); - _key174.resize(_size176); - uint32_t _i180; - for (_i180 = 0; _i180 < _size176; ++_i180) + _key192.clear(); + uint32_t _size194; + ::apache::thrift::protocol::TType _etype197; + xfer += iprot->readListBegin(_etype197, _size194); + _key192.resize(_size194); + uint32_t _i198; + for (_i198 = 0; _i198 < _size194; ++_i198) { - xfer += iprot->readString(_key174[_i180]); + xfer += iprot->readString(_key192[_i198]); } xfer += iprot->readListEnd(); } - std::string& _val175 = this->skewedColValueLocationMaps[_key174]; - xfer += iprot->readString(_val175); + std::string& _val193 = this->skewedColValueLocationMaps[_key192]; + xfer += iprot->readString(_val193); } xfer += iprot->readMapEnd(); } @@ -5001,10 +5747,10 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColNames", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColNames.size())); - std::vector<std::string> ::const_iterator _iter181; - for (_iter181 = this->skewedColNames.begin(); _iter181 != this->skewedColNames.end(); ++_iter181) + std::vector<std::string> ::const_iterator _iter199; + for (_iter199 = this->skewedColNames.begin(); _iter199 != this->skewedColNames.end(); ++_iter199) { - xfer += oprot->writeString((*_iter181)); + xfer += oprot->writeString((*_iter199)); } xfer += oprot->writeListEnd(); } @@ -5013,15 +5759,15 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValues", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_LIST, static_cast<uint32_t>(this->skewedColValues.size())); - std::vector<std::vector<std::string> > ::const_iterator _iter182; - for (_iter182 = this->skewedColValues.begin(); _iter182 != this->skewedColValues.end(); ++_iter182) + std::vector<std::vector<std::string> > ::const_iterator _iter200; + for (_iter200 = this->skewedColValues.begin(); _iter200 != this->skewedColValues.end(); ++_iter200) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter182).size())); - std::vector<std::string> ::const_iterator _iter183; - for (_iter183 = (*_iter182).begin(); _iter183 != (*_iter182).end(); ++_iter183) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*_iter200).size())); + std::vector<std::string> ::const_iterator _iter201; + for (_iter201 = (*_iter200).begin(); _iter201 != (*_iter200).end(); ++_iter201) { - xfer += oprot->writeString((*_iter183)); + xfer += oprot->writeString((*_iter201)); } xfer += oprot->writeListEnd(); } @@ -5033,19 +5779,19 @@ uint32_t SkewedInfo::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("skewedColValueLocationMaps", ::apache::thrift::protocol::T_MAP, 3); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_LIST, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->skewedColValueLocationMaps.size())); - std::map<std::vector<std::string> , std::string> ::const_iterator _iter184; - for (_iter184 = this->skewedColValueLocationMaps.begin(); _iter184 != this->skewedColValueLocationMaps.end(); ++_iter184) + std::map<std::vector<std::string> , std::string> ::const_iterator _iter202; + for (_iter202 = this->skewedColValueLocationMaps.begin(); _iter202 != this->skewedColValueLocationMaps.end(); ++_iter202) { { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter184->first.size())); - std::vector<std::string> ::const_iterator _iter185; - for (_iter185 = _iter184->first.begin(); _iter185 != _iter184->first.end(); ++_iter185) + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(_iter202->first.size())); + std::vector<std::string> ::const_iterator _iter203; + for (_iter203 = _iter202->first.begin(); _iter203 != _iter202->first.end(); ++_iter203) { - xfer += oprot->writeString((*_iter185)); + xfer += oprot->writeString((*_iter203)); } xfer += oprot->writeListEnd(); } - xfer += oprot->writeString(_iter184->second); + xfer += oprot->writeString(_iter202->second); } xfer += oprot->writeMapEnd(); } @@ -5064,17 +5810,17 @@ void swap(SkewedInfo &a, SkewedInfo &b) { swap(a.__isset, b.__isset); } -SkewedInfo::SkewedInfo(const SkewedInfo& other186) { - skewedColNames = other186.skewedColNames; - skewedColValues = other186.skewedColValues; - skewedColValueLocationMaps = other186.skewedColValueLocationMaps; - __isset = other186.__isset; +SkewedInfo::SkewedInfo(const SkewedInfo& other204) { + skewedColNames = other204.skewedColNames; + skewedColValues = other204.skewedColValues; + skewedColValueLocationMaps = other204.skewedColValueLocationMaps; + __isset = other204.__isset; } -SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other187) { - skewedColNames = other187.skewedColNames; - skewedColValues = other187.skewedColValues; - skewedColValueLocationMaps = other187.skewedColValueLocationMaps; - __isset = other187.__isset; +SkewedInfo& SkewedInfo::operator=(const SkewedInfo& other205) { + skewedColNames = other205.skewedColNames; + skewedColValues = other205.skewedColValues; + skewedColValueLocationMaps = other205.skewedColValueLocationMaps; + __isset = other205.__isset; return *this; } void SkewedInfo::printTo(std::ostream& out) const { @@ -5166,14 +5912,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->cols.clear(); - uint32_t _size188; - ::apache::thrift::protocol::TType _etype191; - xfer += iprot->readListBegin(_etype191, _size188); - this->cols.resize(_size188); - uint32_t _i192; - for (_i192 = 0; _i192 < _size188; ++_i192) + uint32_t _size206; + ::apache::thrift::protocol::TType _etype209; + xfer += iprot->readListBegin(_etype209, _size206); + this->cols.resize(_size206); + uint32_t _i210; + for (_i210 = 0; _i210 < _size206; ++_i210) { - xfer += this->cols[_i192].read(iprot); + xfer += this->cols[_i210].read(iprot); } xfer += iprot->readListEnd(); } @@ -5234,14 +5980,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->bucketCols.clear(); - uint32_t _size193; - ::apache::thrift::protocol::TType _etype196; - xfer += iprot->readListBegin(_etype196, _size193); - this->bucketCols.resize(_size193); - uint32_t _i197; - for (_i197 = 0; _i197 < _size193; ++_i197) + uint32_t _size211; + ::apache::thrift::protocol::TType _etype214; + xfer += iprot->readListBegin(_etype214, _size211); + this->bucketCols.resize(_size211); + uint32_t _i215; + for (_i215 = 0; _i215 < _size211; ++_i215) { - xfer += iprot->readString(this->bucketCols[_i197]); + xfer += iprot->readString(this->bucketCols[_i215]); } xfer += iprot->readListEnd(); } @@ -5254,14 +6000,14 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->sortCols.clear(); - uint32_t _size198; - ::apache::thrift::protocol::TType _etype201; - xfer += iprot->readListBegin(_etype201, _size198); - this->sortCols.resize(_size198); - uint32_t _i202; - for (_i202 = 0; _i202 < _size198; ++_i202) + uint32_t _size216; + ::apache::thrift::protocol::TType _etype219; + xfer += iprot->readListBegin(_etype219, _size216); + this->sortCols.resize(_size216); + uint32_t _i220; + for (_i220 = 0; _i220 < _size216; ++_i220) { - xfer += this->sortCols[_i202].read(iprot); + xfer += this->sortCols[_i220].read(iprot); } xfer += iprot->readListEnd(); } @@ -5274,17 +6020,17 @@ uint32_t StorageDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size203; - ::apache::thrift::protocol::TType _ktype204; - ::apache::thrift::protocol::TType _vtype205; - xfer += iprot->readMapBegin(_ktype204, _vtype205, _size203); - uint32_t _i207; - for (_i207 = 0; _i207 < _size203; ++_i207) + uint32_t _size221; + ::apache::thrift::protocol::TType _ktype222; + ::apache::thrift::protocol::TType _vtype223; + xfer += iprot->readMapBegin(_ktype222, _vtype223, _size221); + uint32_t _i225; + for (_i225 = 0; _i225 < _size221; ++_i225) { - std::string _key208; - xfer += iprot->readString(_key208); - std::string& _val209 = this->parameters[_key208]; - xfer += iprot->readString(_val209); + std::string _key226; + xfer += iprot->readString(_key226); + std::string& _val227 = this->parameters[_key226]; + xfer += iprot->readString(_val227); } xfer += iprot->readMapEnd(); } @@ -5329,10 +6075,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("cols", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->cols.size())); - std::vector<FieldSchema> ::const_iterator _iter210; - for (_iter210 = this->cols.begin(); _iter210 != this->cols.end(); ++_iter210) + std::vector<FieldSchema> ::const_iterator _iter228; + for (_iter228 = this->cols.begin(); _iter228 != this->cols.end(); ++_iter228) { - xfer += (*_iter210).write(oprot); + xfer += (*_iter228).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5365,10 +6111,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("bucketCols", ::apache::thrift::protocol::T_LIST, 8); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->bucketCols.size())); - std::vector<std::string> ::const_iterator _iter211; - for (_iter211 = this->bucketCols.begin(); _iter211 != this->bucketCols.end(); ++_iter211) + std::vector<std::string> ::const_iterator _iter229; + for (_iter229 = this->bucketCols.begin(); _iter229 != this->bucketCols.end(); ++_iter229) { - xfer += oprot->writeString((*_iter211)); + xfer += oprot->writeString((*_iter229)); } xfer += oprot->writeListEnd(); } @@ -5377,10 +6123,10 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("sortCols", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sortCols.size())); - std::vector<Order> ::const_iterator _iter212; - for (_iter212 = this->sortCols.begin(); _iter212 != this->sortCols.end(); ++_iter212) + std::vector<Order> ::const_iterator _iter230; + for (_iter230 = this->sortCols.begin(); _iter230 != this->sortCols.end(); ++_iter230) { - xfer += (*_iter212).write(oprot); + xfer += (*_iter230).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5389,11 +6135,11 @@ uint32_t StorageDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("parameters", ::apache::thrift::protocol::T_MAP, 10); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->parameters.size())); - std::map<std::string, std::string> ::const_iterator _iter213; - for (_iter213 = this->parameters.begin(); _iter213 != this->parameters.end(); ++_iter213) + std::map<std::string, std::string> ::const_iterator _iter231; + for (_iter231 = this->parameters.begin(); _iter231 != this->parameters.end(); ++_iter231) { - xfer += oprot->writeString(_iter213->first); - xfer += oprot->writeString(_iter213->second); + xfer += oprot->writeString(_iter231->first); + xfer += oprot->writeString(_iter231->second); } xfer += oprot->writeMapEnd(); } @@ -5431,35 +6177,35 @@ void swap(StorageDescriptor &a, StorageDescriptor &b) { swap(a.__isset, b.__isset); } -StorageDescriptor::StorageDescriptor(const StorageDescriptor& other214) { - cols = other214.cols; - location = other214.location; - inputFormat = other214.inputFormat; - outputFormat = other214.outputFormat; - compressed = other214.compressed; - numBuckets = other214.numBuckets; - serdeInfo = other214.serdeInfo; - bucketCols = other214.bucketCols; - sortCols = other214.sortCols; - parameters = other214.parameters; - skewedInfo = other214.skewedInfo; - storedAsSubDirectories = other214.storedAsSubDirectories; - __isset = other214.__isset; -} -StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other215) { - cols = other215.cols; - location = other215.location; - inputFormat = other215.inputFormat; - outputFormat = other215.outputFormat; - compressed = other215.compressed; - numBuckets = other215.numBuckets; - serdeInfo = other215.serdeInfo; - bucketCols = other215.bucketCols; - sortCols = other215.sortCols; - parameters = other215.parameters; - skewedInfo = other215.skewedInfo; - storedAsSubDirectories = other215.storedAsSubDirectories; - __isset = other215.__isset; +StorageDescriptor::StorageDescriptor(const StorageDescriptor& other232) { + cols = other232.cols; + location = other232.location; + inputFormat = other232.inputFormat; + outputFormat = other232.outputFormat; + compressed = other232.compressed; + numBuckets = other232.numBuckets; + serdeInfo = other232.serdeInfo; + bucketCols = other232.bucketCols; + sortCols = other232.sortCols; + parameters = other232.parameters; + skewedInfo = other232.skewedInfo; + storedAsSubDirectories = other232.storedAsSubDirectories; + __isset = other232.__isset; +} +StorageDescriptor& StorageDescriptor::operator=(const StorageDescriptor& other233) { + cols = other233.cols; + location = other233.location; + inputFormat = other233.inputFormat; + outputFormat = other233.outputFormat; + compressed = other233.compressed; + numBuckets = other233.numBuckets; + serdeInfo = other233.serdeInfo; + bucketCols = other233.bucketCols; + sortCols = other233.sortCols; + parameters = other233.parameters; + skewedInfo = other233.skewedInfo; + storedAsSubDirectories = other233.storedAsSubDirectories; + __isset = other233.__isset; return *this; } void StorageDescriptor::printTo(std::ostream& out) const { @@ -5553,6 +6299,11 @@ void Table::__set_creationMetadata(const CreationMetadata& val) { __isset.creationMetadata = true; } +void Table::__set_catName(const std::string& val) { + this->catName = val; +__isset.catName = true; +} + uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); @@ -5634,14 +6385,14 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partitionKeys.clear(); - uint32_t _size216; - ::apache::thrift::protocol::TType _etype219; - xfer += iprot->readListBegin(_etype219, _size216); - this->partitionKeys.resize(_size216); - uint32_t _i220; - for (_i220 = 0; _i220 < _size216; ++_i220) + uint32_t _size234; + ::apache::thrift::protocol::TType _etype237; + xfer += iprot->readListBegin(_etype237, _size234); + this->partitionKeys.resize(_size234); + uint32_t _i238; + for (_i238 = 0; _i238 < _size234; ++_i238) { - xfer += this->partitionKeys[_i220].read(iprot); + xfer += this->partitionKeys[_i238].read(iprot); } xfer += iprot->readListEnd(); } @@ -5654,17 +6405,17 @@ uint32_t Table::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->parameters.clear(); - uint32_t _size221; - ::apache::thrift::protocol::TType _ktype222; - ::apache::thrift::protocol::TType _vtype223; - xfer += iprot->readMapBegin(_ktype222, _vtype223, _size221); - uint32_t _i225; - for (_i225 = 0; _i225 < _size221; ++_i225) + uint32_t _size239; + ::apache::thrift::protocol::TType _ktype240; +
<TRUNCATED>
