http://git-wip-us.apache.org/repos/asf/hive/blob/696be9f5/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 273d37e..0d4fe5a 100644 --- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size817; - ::apache::thrift::protocol::TType _etype820; - xfer += iprot->readListBegin(_etype820, _size817); - this->success.resize(_size817); - uint32_t _i821; - for (_i821 = 0; _i821 < _size817; ++_i821) + uint32_t _size857; + ::apache::thrift::protocol::TType _etype860; + xfer += iprot->readListBegin(_etype860, _size857); + this->success.resize(_size857); + uint32_t _i861; + for (_i861 = 0; _i861 < _size857; ++_i861) { - xfer += iprot->readString(this->success[_i821]); + xfer += iprot->readString(this->success[_i861]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter822; - for (_iter822 = this->success.begin(); _iter822 != this->success.end(); ++_iter822) + std::vector<std::string> ::const_iterator _iter862; + for (_iter862 = this->success.begin(); _iter862 != this->success.end(); ++_iter862) { - xfer += oprot->writeString((*_iter822)); + xfer += oprot->writeString((*_iter862)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size823; - ::apache::thrift::protocol::TType _etype826; - xfer += iprot->readListBegin(_etype826, _size823); - (*(this->success)).resize(_size823); - uint32_t _i827; - for (_i827 = 0; _i827 < _size823; ++_i827) + uint32_t _size863; + ::apache::thrift::protocol::TType _etype866; + xfer += iprot->readListBegin(_etype866, _size863); + (*(this->success)).resize(_size863); + uint32_t _i867; + for (_i867 = 0; _i867 < _size863; ++_i867) { - xfer += iprot->readString((*(this->success))[_i827]); + xfer += iprot->readString((*(this->success))[_i867]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size828; - ::apache::thrift::protocol::TType _etype831; - xfer += iprot->readListBegin(_etype831, _size828); - this->success.resize(_size828); - uint32_t _i832; - for (_i832 = 0; _i832 < _size828; ++_i832) + uint32_t _size868; + ::apache::thrift::protocol::TType _etype871; + xfer += iprot->readListBegin(_etype871, _size868); + this->success.resize(_size868); + uint32_t _i872; + for (_i872 = 0; _i872 < _size868; ++_i872) { - xfer += iprot->readString(this->success[_i832]); + xfer += iprot->readString(this->success[_i872]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter833; - for (_iter833 = this->success.begin(); _iter833 != this->success.end(); ++_iter833) + std::vector<std::string> ::const_iterator _iter873; + for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873) { - xfer += oprot->writeString((*_iter833)); + xfer += oprot->writeString((*_iter873)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size834; - ::apache::thrift::protocol::TType _etype837; - xfer += iprot->readListBegin(_etype837, _size834); - (*(this->success)).resize(_size834); - uint32_t _i838; - for (_i838 = 0; _i838 < _size834; ++_i838) + uint32_t _size874; + ::apache::thrift::protocol::TType _etype877; + xfer += iprot->readListBegin(_etype877, _size874); + (*(this->success)).resize(_size874); + uint32_t _i878; + for (_i878 = 0; _i878 < _size874; ++_i878) { - xfer += iprot->readString((*(this->success))[_i838]); + xfer += iprot->readString((*(this->success))[_i878]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size839; - ::apache::thrift::protocol::TType _ktype840; - ::apache::thrift::protocol::TType _vtype841; - xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839); - uint32_t _i843; - for (_i843 = 0; _i843 < _size839; ++_i843) + uint32_t _size879; + ::apache::thrift::protocol::TType _ktype880; + ::apache::thrift::protocol::TType _vtype881; + xfer += iprot->readMapBegin(_ktype880, _vtype881, _size879); + uint32_t _i883; + for (_i883 = 0; _i883 < _size879; ++_i883) { - std::string _key844; - xfer += iprot->readString(_key844); - Type& _val845 = this->success[_key844]; - xfer += _val845.read(iprot); + std::string _key884; + xfer += iprot->readString(_key884); + Type& _val885 = this->success[_key884]; + xfer += _val885.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter846; - for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846) + std::map<std::string, Type> ::const_iterator _iter886; + for (_iter886 = this->success.begin(); _iter886 != this->success.end(); ++_iter886) { - xfer += oprot->writeString(_iter846->first); - xfer += _iter846->second.write(oprot); + xfer += oprot->writeString(_iter886->first); + xfer += _iter886->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size847; - ::apache::thrift::protocol::TType _ktype848; - ::apache::thrift::protocol::TType _vtype849; - xfer += iprot->readMapBegin(_ktype848, _vtype849, _size847); - uint32_t _i851; - for (_i851 = 0; _i851 < _size847; ++_i851) + uint32_t _size887; + ::apache::thrift::protocol::TType _ktype888; + ::apache::thrift::protocol::TType _vtype889; + xfer += iprot->readMapBegin(_ktype888, _vtype889, _size887); + uint32_t _i891; + for (_i891 = 0; _i891 < _size887; ++_i891) { - std::string _key852; - xfer += iprot->readString(_key852); - Type& _val853 = (*(this->success))[_key852]; - xfer += _val853.read(iprot); + std::string _key892; + xfer += iprot->readString(_key892); + Type& _val893 = (*(this->success))[_key892]; + xfer += _val893.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size854; - ::apache::thrift::protocol::TType _etype857; - xfer += iprot->readListBegin(_etype857, _size854); - this->success.resize(_size854); - uint32_t _i858; - for (_i858 = 0; _i858 < _size854; ++_i858) + uint32_t _size894; + ::apache::thrift::protocol::TType _etype897; + xfer += iprot->readListBegin(_etype897, _size894); + this->success.resize(_size894); + uint32_t _i898; + for (_i898 = 0; _i898 < _size894; ++_i898) { - xfer += this->success[_i858].read(iprot); + xfer += this->success[_i898].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter859; - for (_iter859 = this->success.begin(); _iter859 != this->success.end(); ++_iter859) + std::vector<FieldSchema> ::const_iterator _iter899; + for (_iter899 = this->success.begin(); _iter899 != this->success.end(); ++_iter899) { - xfer += (*_iter859).write(oprot); + xfer += (*_iter899).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size860; - ::apache::thrift::protocol::TType _etype863; - xfer += iprot->readListBegin(_etype863, _size860); - (*(this->success)).resize(_size860); - uint32_t _i864; - for (_i864 = 0; _i864 < _size860; ++_i864) + uint32_t _size900; + ::apache::thrift::protocol::TType _etype903; + xfer += iprot->readListBegin(_etype903, _size900); + (*(this->success)).resize(_size900); + uint32_t _i904; + for (_i904 = 0; _i904 < _size900; ++_i904) { - xfer += (*(this->success))[_i864].read(iprot); + xfer += (*(this->success))[_i904].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size865; - ::apache::thrift::protocol::TType _etype868; - xfer += iprot->readListBegin(_etype868, _size865); - this->success.resize(_size865); - uint32_t _i869; - for (_i869 = 0; _i869 < _size865; ++_i869) + uint32_t _size905; + ::apache::thrift::protocol::TType _etype908; + xfer += iprot->readListBegin(_etype908, _size905); + this->success.resize(_size905); + uint32_t _i909; + for (_i909 = 0; _i909 < _size905; ++_i909) { - xfer += this->success[_i869].read(iprot); + xfer += this->success[_i909].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter870; - for (_iter870 = this->success.begin(); _iter870 != this->success.end(); ++_iter870) + std::vector<FieldSchema> ::const_iterator _iter910; + for (_iter910 = this->success.begin(); _iter910 != this->success.end(); ++_iter910) { - xfer += (*_iter870).write(oprot); + xfer += (*_iter910).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size871; - ::apache::thrift::protocol::TType _etype874; - xfer += iprot->readListBegin(_etype874, _size871); - (*(this->success)).resize(_size871); - uint32_t _i875; - for (_i875 = 0; _i875 < _size871; ++_i875) + uint32_t _size911; + ::apache::thrift::protocol::TType _etype914; + xfer += iprot->readListBegin(_etype914, _size911); + (*(this->success)).resize(_size911); + uint32_t _i915; + for (_i915 = 0; _i915 < _size911; ++_i915) { - xfer += (*(this->success))[_i875].read(iprot); + xfer += (*(this->success))[_i915].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size876; - ::apache::thrift::protocol::TType _etype879; - xfer += iprot->readListBegin(_etype879, _size876); - this->success.resize(_size876); - uint32_t _i880; - for (_i880 = 0; _i880 < _size876; ++_i880) + uint32_t _size916; + ::apache::thrift::protocol::TType _etype919; + xfer += iprot->readListBegin(_etype919, _size916); + this->success.resize(_size916); + uint32_t _i920; + for (_i920 = 0; _i920 < _size916; ++_i920) { - xfer += this->success[_i880].read(iprot); + xfer += this->success[_i920].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter881; - for (_iter881 = this->success.begin(); _iter881 != this->success.end(); ++_iter881) + std::vector<FieldSchema> ::const_iterator _iter921; + for (_iter921 = this->success.begin(); _iter921 != this->success.end(); ++_iter921) { - xfer += (*_iter881).write(oprot); + xfer += (*_iter921).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size882; - ::apache::thrift::protocol::TType _etype885; - xfer += iprot->readListBegin(_etype885, _size882); - (*(this->success)).resize(_size882); - uint32_t _i886; - for (_i886 = 0; _i886 < _size882; ++_i886) + uint32_t _size922; + ::apache::thrift::protocol::TType _etype925; + xfer += iprot->readListBegin(_etype925, _size922); + (*(this->success)).resize(_size922); + uint32_t _i926; + for (_i926 = 0; _i926 < _size922; ++_i926) { - xfer += (*(this->success))[_i886].read(iprot); + xfer += (*(this->success))[_i926].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size887; - ::apache::thrift::protocol::TType _etype890; - xfer += iprot->readListBegin(_etype890, _size887); - this->success.resize(_size887); - uint32_t _i891; - for (_i891 = 0; _i891 < _size887; ++_i891) + uint32_t _size927; + ::apache::thrift::protocol::TType _etype930; + xfer += iprot->readListBegin(_etype930, _size927); + this->success.resize(_size927); + uint32_t _i931; + for (_i931 = 0; _i931 < _size927; ++_i931) { - xfer += this->success[_i891].read(iprot); + xfer += this->success[_i931].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter892; - for (_iter892 = this->success.begin(); _iter892 != this->success.end(); ++_iter892) + std::vector<FieldSchema> ::const_iterator _iter932; + for (_iter932 = this->success.begin(); _iter932 != this->success.end(); ++_iter932) { - xfer += (*_iter892).write(oprot); + xfer += (*_iter932).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size893; - ::apache::thrift::protocol::TType _etype896; - xfer += iprot->readListBegin(_etype896, _size893); - (*(this->success)).resize(_size893); - uint32_t _i897; - for (_i897 = 0; _i897 < _size893; ++_i897) + uint32_t _size933; + ::apache::thrift::protocol::TType _etype936; + xfer += iprot->readListBegin(_etype936, _size933); + (*(this->success)).resize(_size933); + uint32_t _i937; + for (_i937 = 0; _i937 < _size933; ++_i937) { - xfer += (*(this->success))[_i897].read(iprot); + xfer += (*(this->success))[_i937].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size898; - ::apache::thrift::protocol::TType _etype901; - xfer += iprot->readListBegin(_etype901, _size898); - this->primaryKeys.resize(_size898); - uint32_t _i902; - for (_i902 = 0; _i902 < _size898; ++_i902) + uint32_t _size938; + ::apache::thrift::protocol::TType _etype941; + xfer += iprot->readListBegin(_etype941, _size938); + this->primaryKeys.resize(_size938); + uint32_t _i942; + for (_i942 = 0; _i942 < _size938; ++_i942) { - xfer += this->primaryKeys[_i902].read(iprot); + xfer += this->primaryKeys[_i942].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size903; - ::apache::thrift::protocol::TType _etype906; - xfer += iprot->readListBegin(_etype906, _size903); - this->foreignKeys.resize(_size903); - uint32_t _i907; - for (_i907 = 0; _i907 < _size903; ++_i907) + uint32_t _size943; + ::apache::thrift::protocol::TType _etype946; + xfer += iprot->readListBegin(_etype946, _size943); + this->foreignKeys.resize(_size943); + uint32_t _i947; + for (_i947 = 0; _i947 < _size943; ++_i947) { - xfer += this->foreignKeys[_i907].read(iprot); + xfer += this->foreignKeys[_i947].read(iprot); } xfer += iprot->readListEnd(); } @@ -4554,6 +4554,46 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: xfer += iprot->skip(ftype); } break; + case 4: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->uniqueConstraints.clear(); + uint32_t _size948; + ::apache::thrift::protocol::TType _etype951; + xfer += iprot->readListBegin(_etype951, _size948); + this->uniqueConstraints.resize(_size948); + uint32_t _i952; + for (_i952 = 0; _i952 < _size948; ++_i952) + { + xfer += this->uniqueConstraints[_i952].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.uniqueConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 5: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->notNullConstraints.clear(); + uint32_t _size953; + ::apache::thrift::protocol::TType _etype956; + xfer += iprot->readListBegin(_etype956, _size953); + this->notNullConstraints.resize(_size953); + uint32_t _i957; + for (_i957 = 0; _i957 < _size953; ++_i957) + { + xfer += this->notNullConstraints[_i957].read(iprot); + } + xfer += iprot->readListEnd(); + } + this->__isset.notNullConstraints = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -4578,10 +4618,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter908; - for (_iter908 = this->primaryKeys.begin(); _iter908 != this->primaryKeys.end(); ++_iter908) + std::vector<SQLPrimaryKey> ::const_iterator _iter958; + for (_iter958 = this->primaryKeys.begin(); _iter958 != this->primaryKeys.end(); ++_iter958) { - xfer += (*_iter908).write(oprot); + xfer += (*_iter958).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4590,10 +4630,34 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter909; - for (_iter909 = this->foreignKeys.begin(); _iter909 != this->foreignKeys.end(); ++_iter909) + std::vector<SQLForeignKey> ::const_iterator _iter959; + for (_iter959 = this->foreignKeys.begin(); _iter959 != this->foreignKeys.end(); ++_iter959) { - xfer += (*_iter909).write(oprot); + xfer += (*_iter959).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size())); + std::vector<SQLUniqueConstraint> ::const_iterator _iter960; + for (_iter960 = this->uniqueConstraints.begin(); _iter960 != this->uniqueConstraints.end(); ++_iter960) + { + xfer += (*_iter960).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size())); + std::vector<SQLNotNullConstraint> ::const_iterator _iter961; + for (_iter961 = this->notNullConstraints.begin(); _iter961 != this->notNullConstraints.end(); ++_iter961) + { + xfer += (*_iter961).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4621,10 +4685,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter910; - for (_iter910 = (*(this->primaryKeys)).begin(); _iter910 != (*(this->primaryKeys)).end(); ++_iter910) + std::vector<SQLPrimaryKey> ::const_iterator _iter962; + for (_iter962 = (*(this->primaryKeys)).begin(); _iter962 != (*(this->primaryKeys)).end(); ++_iter962) { - xfer += (*_iter910).write(oprot); + xfer += (*_iter962).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4633,10 +4697,34 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size())); - std::vector<SQLForeignKey> ::const_iterator _iter911; - for (_iter911 = (*(this->foreignKeys)).begin(); _iter911 != (*(this->foreignKeys)).end(); ++_iter911) + std::vector<SQLForeignKey> ::const_iterator _iter963; + for (_iter963 = (*(this->foreignKeys)).begin(); _iter963 != (*(this->foreignKeys)).end(); ++_iter963) + { + xfer += (*_iter963).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->uniqueConstraints)).size())); + std::vector<SQLUniqueConstraint> ::const_iterator _iter964; + for (_iter964 = (*(this->uniqueConstraints)).begin(); _iter964 != (*(this->uniqueConstraints)).end(); ++_iter964) + { + xfer += (*_iter964).write(oprot); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->notNullConstraints)).size())); + std::vector<SQLNotNullConstraint> ::const_iterator _iter965; + for (_iter965 = (*(this->notNullConstraints)).begin(); _iter965 != (*(this->notNullConstraints)).end(); ++_iter965) { - xfer += (*_iter911).write(oprot); + xfer += (*_iter965).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5437,11 +5525,218 @@ uint32_t ThriftHiveMetastore_add_foreign_key_presult::read(::apache::thrift::pro } -ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { +ThriftHiveMetastore_add_unique_constraint_args::~ThriftHiveMetastore_add_unique_constraint_args() throw() { } -uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_unique_constraint_args::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->req.read(iprot); + this->__isset.req = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_args"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_pargs::~ThriftHiveMetastore_add_unique_constraint_pargs() throw() { +} + + +uint32_t ThriftHiveMetastore_add_unique_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { + uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_pargs"); + + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_result::~ThriftHiveMetastore_add_unique_constraint_result() throw() { +} + + +uint32_t ThriftHiveMetastore_add_unique_constraint_result::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->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_add_unique_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_unique_constraint_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_add_unique_constraint_presult::~ThriftHiveMetastore_add_unique_constraint_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_add_unique_constraint_presult::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->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o2.read(iprot); + this->__isset.o2 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_add_not_null_constraint_args::~ThriftHiveMetastore_add_not_null_constraint_args() throw() { +} + + +uint32_t ThriftHiveMetastore_add_not_null_constraint_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5463,25 +5758,9 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T switch (fid) { case 1: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->dbname); - this->__isset.dbname = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 2: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->name); - this->__isset.name = true; - } else { - xfer += iprot->skip(ftype); - } - break; - case 3: - if (ftype == ::apache::thrift::protocol::T_BOOL) { - xfer += iprot->readBool(this->deleteData); - this->__isset.deleteData = true; + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->req.read(iprot); + this->__isset.req = true; } else { xfer += iprot->skip(ftype); } @@ -5498,21 +5777,13 @@ uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_not_null_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); - - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->dbname); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->name); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_args"); - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->req.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5521,25 +5792,17 @@ uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { +ThriftHiveMetastore_add_not_null_constraint_pargs::~ThriftHiveMetastore_add_not_null_constraint_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_not_null_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); - - xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->dbname))); - xfer += oprot->writeFieldEnd(); - - xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->name))); - xfer += oprot->writeFieldEnd(); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_pargs"); - xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); - xfer += oprot->writeBool((*(this->deleteData))); + xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += (*(this->req)).write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -5548,11 +5811,11 @@ uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { +ThriftHiveMetastore_add_not_null_constraint_result::~ThriftHiveMetastore_add_not_null_constraint_result() throw() { } -uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_not_null_constraint_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5583,8 +5846,8 @@ uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol: break; case 2: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; + xfer += this->o2.read(iprot); + this->__isset.o2 = true; } else { xfer += iprot->skip(ftype); } @@ -5601,19 +5864,19 @@ uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_add_not_null_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_not_null_constraint_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o3) { - xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); - xfer += this->o3.write(oprot); + } else if (this->__isset.o2) { + xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o2.write(oprot); xfer += oprot->writeFieldEnd(); } xfer += oprot->writeFieldStop(); @@ -5622,11 +5885,11 @@ uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_drop_table_presult::~ThriftHiveMetastore_drop_table_presult() throw() { +ThriftHiveMetastore_add_not_null_constraint_presult::~ThriftHiveMetastore_add_not_null_constraint_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_add_not_null_constraint_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5657,8 +5920,8 @@ uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol break; case 2: if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->o3.read(iprot); - this->__isset.o3 = true; + xfer += this->o2.read(iprot); + this->__isset.o2 = true; } else { xfer += iprot->skip(ftype); } @@ -5676,11 +5939,11 @@ uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_drop_table_with_environment_context_args::~ThriftHiveMetastore_drop_table_with_environment_context_args() throw() { +ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5725,14 +5988,6 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::ap xfer += iprot->skip(ftype); } break; - case 4: - if (ftype == ::apache::thrift::protocol::T_STRUCT) { - xfer += this->environment_context.read(iprot); - this->__isset.environment_context = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -5745,10 +6000,10 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::ap return xfer; } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_args"); xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->dbname); @@ -5762,24 +6017,20 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::a xfer += oprot->writeBool(this->deleteData); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); - xfer += this->environment_context.write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_drop_table_with_environment_context_pargs::~ThriftHiveMetastore_drop_table_with_environment_context_pargs() throw() { +ThriftHiveMetastore_drop_table_pargs::~ThriftHiveMetastore_drop_table_pargs() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_pargs"); xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->dbname))); @@ -5793,21 +6044,17 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(:: xfer += oprot->writeBool((*(this->deleteData))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); - xfer += (*(this->environment_context)).write(oprot); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_drop_table_with_environment_context_result::~ThriftHiveMetastore_drop_table_with_environment_context_result() throw() { +ThriftHiveMetastore_drop_table_result::~ThriftHiveMetastore_drop_table_result() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5856,11 +6103,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(:: return xfer; } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_result"); if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); @@ -5877,11 +6124,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(: } -ThriftHiveMetastore_drop_table_with_environment_context_presult::~ThriftHiveMetastore_drop_table_with_environment_context_presult() throw() { +ThriftHiveMetastore_drop_table_presult::~ThriftHiveMetastore_drop_table_presult() throw() { } -uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5931,11 +6178,11 @@ uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::read(: } -ThriftHiveMetastore_truncate_table_args::~ThriftHiveMetastore_truncate_table_args() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_args::~ThriftHiveMetastore_drop_table_with_environment_context_args() throw() { } -uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -5958,36 +6205,32 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->dbName); - this->__isset.dbName = true; + xfer += iprot->readString(this->dbname); + this->__isset.dbname = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tableName); - this->__isset.tableName = true; + xfer += iprot->readString(this->name); + this->__isset.name = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->partNames.clear(); - uint32_t _size912; - ::apache::thrift::protocol::TType _etype915; - xfer += iprot->readListBegin(_etype915, _size912); - this->partNames.resize(_size912); - uint32_t _i916; - for (_i916 = 0; _i916 < _size912; ++_i916) - { - xfer += iprot->readString(this->partNames[_i916]); - } - xfer += iprot->readListEnd(); - } - this->__isset.partNames = true; + if (ftype == ::apache::thrift::protocol::T_BOOL) { + xfer += iprot->readBool(this->deleteData); + this->__isset.deleteData = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 4: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->environment_context.read(iprot); + this->__isset.environment_context = true; } else { xfer += iprot->skip(ftype); } @@ -6004,29 +6247,25 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args"); - xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->dbName); + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbname); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); - { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); - std::vector<std::string> ::const_iterator _iter917; - for (_iter917 = this->partNames.begin(); _iter917 != this->partNames.end(); ++_iter917) - { - xfer += oprot->writeString((*_iter917)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool(this->deleteData); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += this->environment_context.write(oprot); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -6035,108 +6274,42 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc } -ThriftHiveMetastore_truncate_table_pargs::~ThriftHiveMetastore_truncate_table_pargs() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_pargs::~ThriftHiveMetastore_drop_table_with_environment_context_pargs() throw() { } -uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs"); - xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->dbName))); + xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbname))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); - { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size())); - std::vector<std::string> ::const_iterator _iter918; - for (_iter918 = (*(this->partNames)).begin(); _iter918 != (*(this->partNames)).end(); ++_iter918) - { - xfer += oprot->writeString((*_iter918)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3); + xfer += oprot->writeBool((*(this->deleteData))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); - xfer += oprot->writeStructEnd(); - return xfer; -} - - -ThriftHiveMetastore_truncate_table_result::~ThriftHiveMetastore_truncate_table_result() throw() { -} - - -uint32_t ThriftHiveMetastore_truncate_table_result::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->o1.read(iprot); - this->__isset.o1 = true; - } else { - xfer += iprot->skip(ftype); - } - break; - default: - xfer += iprot->skip(ftype); - break; - } - xfer += iprot->readFieldEnd(); - } - - xfer += iprot->readStructEnd(); - - return xfer; -} - -uint32_t ThriftHiveMetastore_truncate_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { - - uint32_t xfer = 0; - - xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_result"); + xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4); + xfer += (*(this->environment_context)).write(oprot); + xfer += oprot->writeFieldEnd(); - if (this->__isset.o1) { - xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); - xfer += this->o1.write(oprot); - xfer += oprot->writeFieldEnd(); - } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_truncate_table_presult::~ThriftHiveMetastore_truncate_table_presult() throw() { +ThriftHiveMetastore_drop_table_with_environment_context_result::~ThriftHiveMetastore_drop_table_with_environment_context_result() throw() { } -uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6165,6 +6338,14 @@ uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::prot xfer += iprot->skip(ftype); } break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; default: xfer += iprot->skip(ftype); break; @@ -6177,12 +6358,86 @@ uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::prot return xfer; } +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const { -ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result"); + + if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o3) { + xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2); + xfer += this->o3.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; } -uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { +ThriftHiveMetastore_drop_table_with_environment_context_presult::~ThriftHiveMetastore_drop_table_with_environment_context_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_drop_table_with_environment_context_presult::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->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 2: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o3.read(iprot); + this->__isset.o3 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + + +ThriftHiveMetastore_truncate_table_args::~ThriftHiveMetastore_truncate_table_args() throw() { +} + + +uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6205,16 +6460,36 @@ uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::T { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->db_name); - this->__isset.db_name = true; + xfer += iprot->readString(this->dbName); + this->__isset.dbName = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->pattern); - this->__isset.pattern = true; + xfer += iprot->readString(this->tableName); + this->__isset.tableName = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 3: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + this->partNames.clear(); + uint32_t _size966; + ::apache::thrift::protocol::TType _etype969; + xfer += iprot->readListBegin(_etype969, _size966); + this->partNames.resize(_size966); + uint32_t _i970; + for (_i970 = 0; _i970 < _size966; ++_i970) + { + xfer += iprot->readString(this->partNames[_i970]); + } + xfer += iprot->readListEnd(); + } + this->__isset.partNames = true; } else { xfer += iprot->skip(ftype); } @@ -6231,17 +6506,29 @@ uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::T return xfer; } -uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_args"); - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_name); + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->dbName); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->pattern); + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->tableName); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); + std::vector<std::string> ::const_iterator _iter971; + for (_iter971 = this->partNames.begin(); _iter971 != this->partNames.end(); ++_iter971) + { + xfer += oprot->writeString((*_iter971)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -6250,21 +6537,33 @@ uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol:: } -ThriftHiveMetastore_get_tables_pargs::~ThriftHiveMetastore_get_tables_pargs() throw() { +ThriftHiveMetastore_truncate_table_pargs::~ThriftHiveMetastore_truncate_table_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_pargs"); - xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_name))); + xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->dbName))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->pattern))); + xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->tableName))); + xfer += oprot->writeFieldEnd(); + + xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size())); + std::vector<std::string> ::const_iterator _iter972; + for (_iter972 = (*(this->partNames)).begin(); _iter972 != (*(this->partNames)).end(); ++_iter972) + { + xfer += oprot->writeString((*_iter972)); + } + xfer += oprot->writeListEnd(); + } xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -6273,11 +6572,11 @@ uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol: } -ThriftHiveMetastore_get_tables_result::~ThriftHiveMetastore_get_tables_result() throw() { +ThriftHiveMetastore_truncate_table_result::~ThriftHiveMetastore_truncate_table_result() throw() { } -uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_truncate_table_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6298,26 +6597,6 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->success.clear(); - uint32_t _size919; - ::apache::thrift::protocol::TType _etype922; - xfer += iprot->readListBegin(_etype922, _size919); - this->success.resize(_size919); - uint32_t _i923; - for (_i923 = 0; _i923 < _size919; ++_i923) - { - xfer += iprot->readString(this->success[_i923]); - } - xfer += iprot->readListEnd(); - } - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -6338,25 +6617,13 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: return xfer; } -uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_truncate_table_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_truncate_table_result"); - if (this->__isset.success) { - xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); - { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter924; - for (_iter924 = this->success.begin(); _iter924 != this->success.end(); ++_iter924) - { - xfer += oprot->writeString((*_iter924)); - } - xfer += oprot->writeListEnd(); - } - xfer += oprot->writeFieldEnd(); - } else if (this->__isset.o1) { + if (this->__isset.o1) { xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); xfer += this->o1.write(oprot); xfer += oprot->writeFieldEnd(); @@ -6367,11 +6634,11 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol } -ThriftHiveMetastore_get_tables_presult::~ThriftHiveMetastore_get_tables_presult() throw() { +ThriftHiveMetastore_truncate_table_presult::~ThriftHiveMetastore_truncate_table_presult() throw() { } -uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_truncate_table_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6392,26 +6659,6 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol } switch (fid) { - case 0: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - (*(this->success)).clear(); - uint32_t _size925; - ::apache::thrift::protocol::TType _etype928; - xfer += iprot->readListBegin(_etype928, _size925); - (*(this->success)).resize(_size925); - uint32_t _i929; - for (_i929 = 0; _i929 < _size925; ++_i929) - { - xfer += iprot->readString((*(this->success))[_i929]); - } - xfer += iprot->readListEnd(); - } - this->__isset.success = true; - } else { - xfer += iprot->skip(ftype); - } - break; case 1: if (ftype == ::apache::thrift::protocol::T_STRUCT) { xfer += this->o1.read(iprot); @@ -6433,11 +6680,11 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol } -ThriftHiveMetastore_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() throw() { +ThriftHiveMetastore_get_tables_args::~ThriftHiveMetastore_get_tables_args() throw() { } -uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6474,14 +6721,6 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::pro xfer += iprot->skip(ftype); } break; - case 3: - if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tableType); - this->__isset.tableType = true; - } else { - xfer += iprot->skip(ftype); - } - break; default: xfer += iprot->skip(ftype); break; @@ -6494,10 +6733,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::pro return xfer; } -uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_tables_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_args"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString(this->db_name); @@ -6507,24 +6746,20 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::pr xfer += oprot->writeString(this->pattern); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString(this->tableType); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() throw() { +ThriftHiveMetastore_get_tables_pargs::~ThriftHiveMetastore_get_tables_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_tables_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_pargs"); xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); xfer += oprot->writeString((*(this->db_name))); @@ -6534,21 +6769,17 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::p xfer += oprot->writeString((*(this->pattern))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); - xfer += oprot->writeString((*(this->tableType))); - xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); return xfer; } -ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() throw() { +ThriftHiveMetastore_get_tables_result::~ThriftHiveMetastore_get_tables_result() throw() { } -uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6573,14 +6804,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size930; - ::apache::thrift::protocol::TType _etype933; - xfer += iprot->readListBegin(_etype933, _size930); - this->success.resize(_size930); - uint32_t _i934; - for (_i934 = 0; _i934 < _size930; ++_i934) + uint32_t _size973; + ::apache::thrift::protocol::TType _etype976; + xfer += iprot->readListBegin(_etype976, _size973); + this->success.resize(_size973); + uint32_t _i977; + for (_i977 = 0; _i977 < _size973; ++_i977) { - xfer += iprot->readString(this->success[_i934]); + xfer += iprot->readString(this->success[_i977]); } xfer += iprot->readListEnd(); } @@ -6609,20 +6840,20 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p return xfer; } -uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_result"); if (this->__isset.success) { xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter935; - for (_iter935 = this->success.begin(); _iter935 != this->success.end(); ++_iter935) + std::vector<std::string> ::const_iterator _iter978; + for (_iter978 = this->success.begin(); _iter978 != this->success.end(); ++_iter978) { - xfer += oprot->writeString((*_iter935)); + xfer += oprot->writeString((*_iter978)); } xfer += oprot->writeListEnd(); } @@ -6638,11 +6869,11 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: } -ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() throw() { +ThriftHiveMetastore_get_tables_presult::~ThriftHiveMetastore_get_tables_presult() throw() { } -uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6667,14 +6898,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size936; - ::apache::thrift::protocol::TType _etype939; - xfer += iprot->readListBegin(_etype939, _size936); - (*(this->success)).resize(_size936); - uint32_t _i940; - for (_i940 = 0; _i940 < _size936; ++_i940) + uint32_t _size979; + ::apache::thrift::protocol::TType _etype982; + xfer += iprot->readListBegin(_etype982, _size979); + (*(this->success)).resize(_size979); + uint32_t _i983; + for (_i983 = 0; _i983 < _size979; ++_i983) { - xfer += iprot->readString((*(this->success))[_i940]); + xfer += iprot->readString((*(this->success))[_i983]); } xfer += iprot->readListEnd(); } @@ -6704,11 +6935,11 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: } -ThriftHiveMetastore_get_table_meta_args::~ThriftHiveMetastore_get_table_meta_args() throw() { +ThriftHiveMetastore_get_tables_by_type_args::~ThriftHiveMetastore_get_tables_by_type_args() throw() { } -uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_tables_by_type_args::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6731,36 +6962,24 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco { case 1: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->db_patterns); - this->__isset.db_patterns = true; + xfer += iprot->readString(this->db_name); + this->__isset.db_name = true; } else { xfer += iprot->skip(ftype); } break; case 2: if (ftype == ::apache::thrift::protocol::T_STRING) { - xfer += iprot->readString(this->tbl_patterns); - this->__isset.tbl_patterns = true; + xfer += iprot->readString(this->pattern); + this->__isset.pattern = true; } else { xfer += iprot->skip(ftype); } break; case 3: - if (ftype == ::apache::thrift::protocol::T_LIST) { - { - this->tbl_types.clear(); - uint32_t _size941; - ::apache::thrift::protocol::TType _etype944; - xfer += iprot->readListBegin(_etype944, _size941); - this->tbl_types.resize(_size941); - uint32_t _i945; - for (_i945 = 0; _i945 < _size941; ++_i945) - { - xfer += iprot->readString(this->tbl_types[_i945]); - } - xfer += iprot->readListEnd(); - } - this->__isset.tbl_types = true; + if (ftype == ::apache::thrift::protocol::T_STRING) { + xfer += iprot->readString(this->tableType); + this->__isset.tableType = true; } else { xfer += iprot->skip(ftype); } @@ -6777,29 +6996,21 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco return xfer; } -uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_tables_by_type_args::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_args"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_args"); - xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString(this->db_patterns); + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString(this->db_name); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString(this->tbl_patterns); + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString(this->pattern); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); - { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size())); - std::vector<std::string> ::const_iterator _iter946; - for (_iter946 = this->tbl_types.begin(); _iter946 != this->tbl_types.end(); ++_iter946) - { - xfer += oprot->writeString((*_iter946)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString(this->tableType); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -6808,33 +7019,25 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc } -ThriftHiveMetastore_get_table_meta_pargs::~ThriftHiveMetastore_get_table_meta_pargs() throw() { +ThriftHiveMetastore_get_tables_by_type_pargs::~ThriftHiveMetastore_get_tables_by_type_pargs() throw() { } -uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { +uint32_t ThriftHiveMetastore_get_tables_by_type_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); - xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_table_meta_pargs"); + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_pargs"); - xfer += oprot->writeFieldBegin("db_patterns", ::apache::thrift::protocol::T_STRING, 1); - xfer += oprot->writeString((*(this->db_patterns))); + xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1); + xfer += oprot->writeString((*(this->db_name))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tbl_patterns", ::apache::thrift::protocol::T_STRING, 2); - xfer += oprot->writeString((*(this->tbl_patterns))); + xfer += oprot->writeFieldBegin("pattern", ::apache::thrift::protocol::T_STRING, 2); + xfer += oprot->writeString((*(this->pattern))); xfer += oprot->writeFieldEnd(); - xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); - { - xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size())); - std::vector<std::string> ::const_iterator _iter947; - for (_iter947 = (*(this->tbl_types)).begin(); _iter947 != (*(this->tbl_types)).end(); ++_iter947) - { - xfer += oprot->writeString((*_iter947)); - } - xfer += oprot->writeListEnd(); - } + xfer += oprot->writeFieldBegin("tableType", ::apache::thrift::protocol::T_STRING, 3); + xfer += oprot->writeString((*(this->tableType))); xfer += oprot->writeFieldEnd(); xfer += oprot->writeFieldStop(); @@ -6843,11 +7046,11 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto } -ThriftHiveMetastore_get_table_meta_result::~ThriftHiveMetastore_get_table_meta_result() throw() { +ThriftHiveMetastore_get_tables_by_type_result::~ThriftHiveMetastore_get_tables_by_type_result() throw() { } -uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::protocol::TProtocol* iprot) { +uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::protocol::TProtocol* iprot) { apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; @@ -6872,14 +7075,313 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size948; - ::apache::thrift::protocol::TType _etype951; - xfer += iprot->readListBegin(_etype951, _size948); - this->success.resize(_size948); - uint32_t _i952; - for (_i952 = 0; _i952 < _size948; ++_i952) + uint32_t _size984; + ::apache::thrift::protocol::TType _etype987; + xfer += iprot->readListBegin(_etype987, _size984); + this->success.resize(_size984); + uint32_t _i988; + for (_i988 = 0; _i988 < _size984; ++_i988) + { + xfer += iprot->readString(this->success[_i988]); + } + xfer += iprot->readListEnd(); + } + this->__isset.success = true; + } else { + xfer += iprot->skip(ftype); + } + break; + case 1: + if (ftype == ::apache::thrift::protocol::T_STRUCT) { + xfer += this->o1.read(iprot); + this->__isset.o1 = true; + } else { + xfer += iprot->skip(ftype); + } + break; + default: + xfer += iprot->skip(ftype); + break; + } + xfer += iprot->readFieldEnd(); + } + + xfer += iprot->readStructEnd(); + + return xfer; +} + +uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const { + + uint32_t xfer = 0; + + xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result"); + + if (this->__isset.success) { + xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); + { + xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); + std::vector<std::string> ::const_iterator _iter989; + for (_iter989 = this->success.begin(); _iter989 != this->success.end(); ++_iter989) + { + xfer += oprot->writeString((*_iter989)); + } + xfer += oprot->writeListEnd(); + } + xfer += oprot->writeFieldEnd(); + } else if (this->__isset.o1) { + xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1); + xfer += this->o1.write(oprot); + xfer += oprot->writeFieldEnd(); + } + xfer += oprot->writeFieldStop(); + xfer += oprot->writeStructEnd(); + return xfer; +} + + +ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() throw() { +} + + +uint32_t ThriftHiveMetastore_get_tables_by_type_presult::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 0: + if (ftype == ::apache::thrift::protocol::T_LIST) { + { + (*(this->success)).clear(); + uint32_t _size990; + ::apache::thrift::protocol::TType _etype993; + xfer += iprot->readListBegin(_etype993, _size990); + (*(this->success)).resize(_size990); + uint32_t _i994; + for (_i994 = 0; _i994 < _size990; ++_i994) { - xfer += this->success[_i952].read(iprot); + xfer
<TRUNCATED>